jsonapi-resources 0.7.1.beta1 → 0.7.1.beta2

data/lib/jsonapi/{request.rb → request_parser.rb}

@@ -2,7 +2,7 @@ require 'jsonapi/operation'
 require 'jsonapi/paginator'
 
 module JSONAPI
-  class Request
+  class RequestParser
     attr_accessor :fields, :include, :filters, :sort_criteria, :errors, :operations,
                   :resource_klass, :context, :paginator, :source_klass, :source_id,
                   :include_directives, :params, :warnings, :server_error_callbacks
@@ -289,27 +289,29 @@ module JSONAPI
     end
 
     def add_find_operation
-      @operations.push JSONAPI::FindOperation.new(
+      @operations.push JSONAPI::Operation.new(:find,
         @resource_klass,
         context: @context,
         filters: @filters,
         include_directives: @include_directives,
         sort_criteria: @sort_criteria,
-        paginator: @paginator
+        paginator: @paginator,
+        fields: @fields
       )
     end
 
     def add_show_operation
-      @operations.push JSONAPI::ShowOperation.new(
+      @operations.push JSONAPI::Operation.new(:show,
         @resource_klass,
         context: @context,
         id: @id,
-        include_directives: @include_directives
+        include_directives: @include_directives,
+        fields: @fields
       )
     end
 
     def add_show_relationship_operation(relationship_type, parent_key)
-      @operations.push JSONAPI::ShowRelationshipOperation.new(
+      @operations.push JSONAPI::Operation.new(:show_relationship,
         @resource_klass,
         context: @context,
         relationship_type: relationship_type,
@@ -318,17 +320,18 @@ module JSONAPI
     end
 
     def add_show_related_resource_operation(relationship_type)
-      @operations.push JSONAPI::ShowRelatedResourceOperation.new(
+      @operations.push JSONAPI::Operation.new(:show_related_resource,
         @resource_klass,
         context: @context,
         relationship_type: relationship_type,
         source_klass: @source_klass,
-        source_id: @source_id
+        source_id: @source_id,
+        fields: @fields
       )
     end
 
     def add_show_related_resources_operation(relationship_type)
-      @operations.push JSONAPI::ShowRelatedResourcesOperation.new(
+      @operations.push JSONAPI::Operation.new(:show_related_resources,
         @resource_klass,
         context: @context,
         relationship_type: relationship_type,
@@ -336,7 +339,8 @@ module JSONAPI
         source_id: @source_id,
         filters: @source_klass.verify_filters(@filters, @context),
         sort_criteria: @sort_criteria,
-        paginator: @paginator
+        paginator: @paginator,
+        fields: @fields
       )
     end
 
@@ -356,10 +360,11 @@ module JSONAPI
         verify_type(params[:type])
 
         data = parse_params(params, creatable_fields)
-        @operations.push JSONAPI::CreateResourceOperation.new(
+        @operations.push JSONAPI::Operation.new(:create_resource,
           @resource_klass,
           context: @context,
-          data: data
+          data: data,
+          fields: @fields
         )
       end
     rescue JSONAPI::Exceptions::Error => e
@@ -382,7 +387,8 @@ module JSONAPI
         }
       end
 
-      if !raw.is_a?(Hash) || raw.length != 2 || !(raw.key?('type') && raw.key?('id'))
+      if !(raw.is_a?(Hash) || raw.is_a?(ActionController::Parameters)) ||
+         raw.keys.length != 2 || !(raw.key?('type') && raw.key?('id'))
         fail JSONAPI::Exceptions::InvalidLinksObject.new
       end
 
@@ -476,7 +482,7 @@ module JSONAPI
     def parse_to_many_relationship(link_value, relationship, &add_result)
       if link_value.is_a?(Array) && link_value.length == 0
         linkage = []
-      elsif link_value.is_a?(Hash)
+      elsif (link_value.is_a?(Hash) || link_value.is_a?(ActionController::Parameters))
         linkage = link_value[:data]
       else
         fail JSONAPI::Exceptions::InvalidLinksObject.new
@@ -531,7 +537,14 @@ module JSONAPI
               end
             end
           end
-        when 'type', 'id'
+        when 'type'
+        when 'id'
+          unless formatted_allowed_fields.include?(:id)
+            params_not_allowed.push(:id)
+            unless JSONAPI.configuration.raise_if_parameters_not_allowed
+              params.delete :id
+            end
+          end
         else
           params_not_allowed.push(key)
         end
@@ -564,7 +577,7 @@ module JSONAPI
 
     def parse_add_relationship_operation(verified_params, relationship, parent_key)
       if relationship.is_a?(JSONAPI::Relationship::ToMany)
-        @operations.push JSONAPI::CreateToManyRelationshipOperation.new(
+        @operations.push JSONAPI::Operation.new(:create_to_many_relationship,
           resource_klass,
           context: @context,
           resource_id: parent_key,
@@ -575,40 +588,37 @@ module JSONAPI
     end
 
     def parse_update_relationship_operation(verified_params, relationship, parent_key)
-      operation_args = [resource_klass].push(
+      options = {
         context: @context,
         resource_id: parent_key,
         relationship_type: relationship.name
-      )
+      }
 
       if relationship.is_a?(JSONAPI::Relationship::ToOne)
         if relationship.polymorphic?
-          operation_args[1].merge!(
-            key_value: verified_params[:to_one].values[0][:id],
-            key_type: verified_params[:to_one].values[0][:type]
-          )
+          options[:key_value] = verified_params[:to_one].values[0][:id]
+          options[:key_type] = verified_params[:to_one].values[0][:type]
 
-          operation_klass = JSONAPI::ReplacePolymorphicToOneRelationshipOperation
+          operation_type = :replace_polymorphic_to_one_relationship
         else
-          operation_args[1].merge!(key_value: verified_params[:to_one].values[0])
-          operation_klass = JSONAPI::ReplaceToOneRelationshipOperation
+          options[:key_value] = verified_params[:to_one].values[0]
+          operation_type = :replace_to_one_relationship
         end
       elsif relationship.is_a?(JSONAPI::Relationship::ToMany)
         unless relationship.acts_as_set
           fail JSONAPI::Exceptions::ToManySetReplacementForbidden.new
         end
-
-        operation_args[1].merge!(data: verified_params[:to_many].values[0])
-        operation_klass = JSONAPI::ReplaceToManyRelationshipOperation
+        options[:data] = verified_params[:to_many].values[0]
+        operation_type = :replace_to_many_relationship
       end
 
-      @operations.push(operation_klass.send(:new, *operation_args))
+      @operations.push JSONAPI::Operation.new(operation_type, resource_klass, options)
     end
 
     def parse_single_replace_operation(data, keys, id_key_presence_check_required: true)
       fail JSONAPI::Exceptions::MissingKey.new if data[:id].nil?
 
-      key = data[:id]
+      key = data[:id].to_s
       if id_key_presence_check_required && !keys.include?(key)
         fail JSONAPI::Exceptions::KeyNotIncludedInURL.new(key)
       end
@@ -617,11 +627,12 @@ module JSONAPI
 
       verify_type(data[:type])
 
-      @operations.push JSONAPI::ReplaceFieldsOperation.new(
+      @operations.push JSONAPI::Operation.new(:replace_fields,
         @resource_klass,
         context: @context,
         resource_id: key,
-        data: parse_params(data, updatable_fields)
+        data: parse_params(data, updatable_fields),
+        fields: @fields
       )
     end
 
@@ -645,7 +656,7 @@ module JSONAPI
       keys = parse_key_array(params.require(:id))
 
       keys.each do |key|
-        @operations.push JSONAPI::RemoveResourceOperation.new(
+        @operations.push JSONAPI::Operation.new(:remove_resource,
           @resource_klass,
           context: @context,
           resource_id: key
@@ -667,12 +678,12 @@ module JSONAPI
         keys.each do |key|
           operation_args = operation_base_args.dup
           operation_args[1] = operation_args[1].merge(associated_key: key)
-          @operations.push JSONAPI::RemoveToManyRelationshipOperation.new(
+          @operations.push JSONAPI::Operation.new(:remove_to_many_relationship,
             *operation_args
           )
         end
       else
-        @operations.push JSONAPI::RemoveToOneRelationshipOperation.new(
+        @operations.push JSONAPI::Operation.new(:remove_to_one_relationship,
           *operation_base_args
         )
       end

data/lib/jsonapi/resource.rb

@@ -152,6 +152,15 @@ module JSONAPI
       {}
     end
 
+    # Override this to return custom links
+    # must return a hash, which will be merged with the default { self: 'self-url' } links hash
+    # links keys will be not be formatted with the key formatter for the serializer by default.
+    # They can however use the serializer's format_key and format_value methods if desired
+    # the _options hash will contain the serializer and the serialization_options
+    def custom_links(_options)
+      {}
+    end
+
     private
 
     def save
@@ -173,8 +182,8 @@ module JSONAPI
     #   return :accepted
     # end
     # ```
-    def _save
-      unless @model.valid?
+    def _save(validation_context = nil)
+      unless @model.valid?(validation_context)
         fail JSONAPI::Exceptions::ValidationErrors.new(self)
       end
 
@@ -201,6 +210,9 @@ module JSONAPI
         fail JSONAPI::Exceptions::ValidationErrors.new(self)
       end
       :completed
+
+    rescue ActiveRecord::DeleteRestrictionError => e
+      fail JSONAPI::Exceptions::RecordLocked.new(e.message)
     end
 
     def _create_to_many_links(relationship_type, relationship_key_values)
@@ -256,6 +268,11 @@ module JSONAPI
       @model.public_send(relation_name).delete(key)
 
       :completed
+
+    rescue ActiveRecord::DeleteRestrictionError => e
+      fail JSONAPI::Exceptions::RecordLocked.new(e.message)
+    rescue ActiveRecord::RecordNotFound
+      fail JSONAPI::Exceptions::RecordNotFound.new(key)
     end
 
     def _remove_to_one_link(relationship_type)
@@ -390,11 +407,11 @@ module JSONAPI
         @_attributes ||= {}
         @_attributes[attr] = options
         define_method attr do
-          @model.public_send(attr)
+          @model.public_send(options[:delegate] ? options[:delegate].to_sym : attr)
         end unless method_defined?(attr)
 
         define_method "#{attr}=" do |value|
-          @model.public_send "#{attr}=", value
+          @model.public_send("#{options[:delegate] ? options[:delegate].to_sym : attr}=", value)
         end unless method_defined?("#{attr}=")
       end
 
@@ -521,17 +538,57 @@ module JSONAPI
 
       def apply_sort(records, order_options, _context = {})
         if order_options.any?
-          records.order(order_options)
-        else
-          records
+           order_options.each_pair do |field, direction|
+            if field.to_s.include?(".")
+              *model_names, column_name = field.split(".")
+
+              associations = _lookup_association_chain([records.model.to_s, *model_names])
+              joins_query = _build_joins([records.model, *associations])
+
+              # _sorting is appended to avoid name clashes with manual joins eg. overriden filters
+              order_by_query = "#{associations.last.name}_sorting.#{column_name} #{direction}"
+              records = records.joins(joins_query).order(order_by_query)
+            else
+              records = records.order(field => direction)
+            end
+          end
+        end
+
+        records
+      end
+
+      def _lookup_association_chain(model_names)
+        associations = []
+        model_names.inject do |prev, current|
+          association = prev.classify.constantize.reflect_on_all_associations.detect do |assoc|
+            assoc.name.to_s.downcase == current.downcase
+          end
+          associations << association
+          association.class_name
+        end
+
+        associations
+      end
+
+      def _build_joins(associations)
+        joins = []
+
+        associations.inject do |prev, current|
+          joins << "LEFT JOIN #{current.table_name} AS #{current.name}_sorting ON #{current.name}_sorting.id = #{prev.table_name}.#{current.foreign_key}"
+          current
         end
+        joins.join("\n")
       end
 
       def apply_filter(records, filter, value, options = {})
         strategy = _allowed_filters.fetch(filter.to_sym, Hash.new)[:apply]
 
         if strategy
-          strategy.call(records, value, options)
+          if strategy.is_a?(Symbol) || strategy.is_a?(String)
+            send(strategy, records, value, options)
+          else
+            strategy.call(records, value, options)
+          end
         else
           records.where(filter => value)
         end
@@ -571,8 +628,13 @@ module JSONAPI
         apply_sort(records, order_options, context)
       end
 
+      # Assumes ActiveRecord's counting. Override if you need a different counting method
+      def count_records(records)
+        records.count(:all)
+      end
+
       def find_count(filters, options = {})
-        filter_records(filters, options).count(:all)
+        count_records(filter_records(filters, options))
       end
 
       # Override this method if you have more complex requirements than this basic find method provides
@@ -587,9 +649,15 @@ module JSONAPI
 
         records = apply_pagination(records, options[:paginator], order_options)
 
+        resources_for(records, context)
+      end
+
+      def resources_for(records, context)
         resources = []
+        resource_classes = {}
         records.each do |model|
-          resources.push self.resource_for_model(model).new(model, context)
+          resource_class = resource_classes[model.class] ||= self.resource_for_model(model)
+          resources.push resource_class.new(model, context)
         end
 
         resources
@@ -625,12 +693,19 @@ module JSONAPI
 
       def verify_filter(filter, raw, context = nil)
         filter_values = []
-        filter_values += CSV.parse_line(raw) unless raw.nil? || raw.empty?
+        if raw.present?
+          filter_values += raw.is_a?(String) ? CSV.parse_line(raw) : [raw]
+        end
 
         strategy = _allowed_filters.fetch(filter, Hash.new)[:verify]
 
         if strategy
-          [filter, strategy.call(filter_values, context)]
+          if strategy.is_a?(Symbol) || strategy.is_a?(String)
+            values = send(strategy, filter_values, context)
+          else
+            values = strategy.call(filter_values, context)
+          end
+          [filter, values]
         else
           if is_filter_relationship?(filter)
             verify_relationship_filter(filter, filter_values, context)
@@ -645,7 +720,7 @@ module JSONAPI
       end
 
       def resource_key_type
-        @_resource_key_type || JSONAPI.configuration.resource_key_type
+        @_resource_key_type ||= JSONAPI.configuration.resource_key_type
       end
 
       def verify_key(key, context = nil)

data/lib/jsonapi/resource_controller.rb

@@ -1,17 +1,5 @@
 module JSONAPI
-  class ResourceController < ActionController::Metal
-    MODULES = [
-      AbstractController::Rendering,
-      ActionController::Rendering,
-      ActionController::Renderers::All,
-      ActionController::StrongParameters,
-      ActionController::ForceSSL,
-      ActionController::Instrumentation,
-      JSONAPI::ActsAsResourceController
-    ].freeze
-
-    MODULES.each do |mod|
-      include mod
-    end
+  class ResourceController < ActionController::Base
+    include JSONAPI::ActsAsResourceController
   end
 end

data/lib/jsonapi/resource_controller_metal.rb

@@ -0,0 +1,17 @@
+module JSONAPI
+  class ResourceControllerMetal < ActionController::Metal
+    MODULES = [
+      AbstractController::Rendering,
+      ActionController::Rendering,
+      ActionController::Renderers::All,
+      ActionController::StrongParameters,
+      ActionController::ForceSSL,
+      ActionController::Instrumentation,
+      JSONAPI::ActsAsResourceController
+    ].freeze
+
+    MODULES.each do |mod|
+      include mod
+    end
+  end
+end

data/lib/jsonapi/resource_serializer.rb

@@ -12,7 +12,7 @@ module JSONAPI
     #     Purpose: determines which fields are serialized for a resource type. This encompasses both attributes and
     #              relationship ids in the links section for a resource. Fields are global for a resource type.
     #     Example: { people: [:id, :email, :comments], posts: [:id, :title, :author], comments: [:id, :body, :post]}
-    # key_formatter: KeyFormatter class to override the default configuration
+    # key_formatter: KeyFormatter instance to override the default configuration
     # serializer_options: additional options that will be passed to resource meta and links lambdas
 
     def initialize(primary_resource_klass, options = {})
@@ -21,16 +21,23 @@ module JSONAPI
       @include            = options.fetch(:include, [])
       @include_directives = options[:include_directives]
       @key_formatter      = options.fetch(:key_formatter, JSONAPI.configuration.key_formatter)
+      @id_formatter       = ValueFormatter.value_formatter_for(:id)
       @link_builder       = generate_link_builder(primary_resource_klass, options)
       @always_include_to_one_linkage_data = options.fetch(:always_include_to_one_linkage_data,
                                                           JSONAPI.configuration.always_include_to_one_linkage_data)
       @always_include_to_many_linkage_data = options.fetch(:always_include_to_many_linkage_data,
                                                            JSONAPI.configuration.always_include_to_many_linkage_data)
       @serialization_options = options.fetch(:serialization_options, {})
+
+      # Warning: This makes ResourceSerializer non-thread-safe. That's not a problem with the
+      # request-specific way it's currently used, though.
+      @value_formatter_type_cache = NaiveCache.new{|arg| ValueFormatter.value_formatter_for(arg) }
     end
 
     # Converts a single resource, or an array of resources to a hash, conforming to the JSONAPI structure
     def serialize_to_hash(source)
+      @top_level_sources = Set.new([source].flatten.compact.map {|s| top_level_source_key(s) })
+
       is_resource_collection = source.respond_to?(:to_ary)
 
       @included_objects = {}
@@ -81,8 +88,7 @@ module JSONAPI
     end
 
     def format_value(value, format)
-      value_formatter = JSONAPI::ValueFormatter.value_formatter_for(format)
-      value_formatter.format(value)
+      @value_formatter_type_cache.get(format).format(value)
     end
 
     private
@@ -114,19 +120,18 @@ module JSONAPI
 
       obj_hash['type'] = format_key(source.class._type.to_s)
 
-      links = relationship_links(source)
+      links = links_hash(source)
       obj_hash['links'] = links unless links.empty?
 
-      attributes = attribute_hash(source)
+      attributes = attributes_hash(source)
       obj_hash['attributes'] = attributes unless attributes.empty?
 
-      relationships = relationship_data(source, include_directives)
+      relationships = relationships_hash(source, include_directives)
       obj_hash['relationships'] = relationships unless relationships.nil? || relationships.empty?
 
-      meta = source.meta(custom_generation_options)
-      if meta.is_a?(Hash) && !meta.empty?
-        obj_hash['meta'] = meta
-      end
+      meta = meta_hash(source)
+      obj_hash['meta'] = meta unless meta.empty?
+
       obj_hash
     end
 
@@ -139,7 +144,7 @@ module JSONAPI
       end
     end
 
-    def attribute_hash(source)
+    def attributes_hash(source)
       requested = requested_fields(source.class)
       fields = source.fetchable_fields & source.class._attributes.keys.to_a
       fields = requested & fields unless requested.nil?
@@ -159,7 +164,31 @@ module JSONAPI
       }
     end
 
-    def relationship_data(source, include_directives)
+    def meta_hash(source)
+      meta = source.meta(custom_generation_options)
+      (meta.is_a?(Hash) && meta) || {}
+    end
+
+    def links_hash(source)
+      {
+        self: link_builder.self_link(source)
+      }.merge(custom_links_hash(source)).compact
+    end
+
+    def custom_links_hash(source)
+      custom_links = source.custom_links(custom_generation_options)
+      (custom_links.is_a?(Hash) && custom_links) || {}
+    end
+
+    def top_level_source_key(source)
+      "#{source.class}_#{source.id}"
+    end
+
+    def self_referential_and_already_in_source(resource)
+      resource && @top_level_sources.include?(top_level_source_key(resource))
+    end
+
+    def relationships_hash(source, include_directives)
       relationships = source.class._relationships
       requested = requested_fields(source.class)
       fields = relationships.keys
@@ -177,39 +206,24 @@ module JSONAPI
 
           include_linkage = ia && ia[:include]
           include_linked_children = ia && !ia[:include_related].empty?
+          resources = (include_linkage || include_linked_children) && [source.public_send(name)].flatten.compact
 
           if field_set.include?(name)
             hash[format_key(name)] = link_object(source, relationship, include_linkage)
           end
 
-          type = relationship.type
-
           # If the object has been serialized once it will be in the related objects list,
           # but it's possible all children won't have been captured. So we must still go
           # through the relationships.
           if include_linkage || include_linked_children
-            if relationship.is_a?(JSONAPI::Relationship::ToOne)
-              resource = source.public_send(name)
-              if resource
-                id = resource.id
-                type = relationship.type_for_source(source)
-                relationships_only = already_serialized?(type, id)
-                if include_linkage && !relationships_only
-                  add_included_object(id, object_hash(resource, ia))
-                elsif include_linked_children || relationships_only
-                  relationship_data(resource, ia)
-                end
-              end
-            elsif relationship.is_a?(JSONAPI::Relationship::ToMany)
-              resources = source.public_send(name)
-              resources.each do |resource|
-                id = resource.id
-                relationships_only = already_serialized?(type, id)
-                if include_linkage && !relationships_only
-                  add_included_object(id, object_hash(resource, ia))
-                elsif include_linked_children || relationships_only
-                  relationship_data(resource, ia)
-                end
+            resources.each do |resource|
+              next if self_referential_and_already_in_source(resource)
+              id = resource.id
+              relationships_only = already_serialized?(relationship.type, id)
+              if include_linkage && !relationships_only
+                add_included_object(id, object_hash(resource, ia))
+              elsif include_linked_children || relationships_only
+                relationships_hash(resource, ia)
               end
             end
           end
@@ -217,13 +231,6 @@ module JSONAPI
       end
     end
 
-    def relationship_links(source)
-      links = {}
-      links[:self] = link_builder.self_link(source)
-
-      links
-    end
-
     def already_serialized?(type, id)
       type = format_key(type)
       @included_objects.key?(type) && @included_objects[type].key?(id)
@@ -292,18 +299,26 @@ module JSONAPI
     def foreign_key_value(source, relationship)
       foreign_key = relationship.foreign_key
       value = source.public_send(foreign_key)
-      IdValueFormatter.format(value)
+      @id_formatter.format(value)
     end
 
     def foreign_key_types_and_values(source, relationship)
       if relationship.is_a?(JSONAPI::Relationship::ToMany)
         if relationship.polymorphic?
-          source._model.public_send(relationship.name).pluck(:type, :id).map do |type, id|
-            [type.pluralize, IdValueFormatter.format(id)]
+          assoc = source._model.public_send(relationship.name)
+          # Avoid hitting the database again for values already pre-loaded
+          if assoc.respond_to?(:loaded?) and assoc.loaded?
+            assoc.map do |obj|
+              [obj.type.underscore.pluralize, @id_formatter.format(obj.id)]
+            end
+          else
+            assoc.pluck(:type, :id).map do |type, id|
+              [type.underscore.pluralize, @id_formatter.format(id)]
+            end
           end
         else
           source.public_send(relationship.foreign_key).map do |value|
-            [relationship.type, IdValueFormatter.format(value)]
+            [relationship.type, @id_formatter.format(value)]
           end
         end
       end