jsonapi-resources 0.3.3 → 0.4.0

data/lib/jsonapi/resource.rb

@@ -1,5 +1,3 @@
-require 'jsonapi/configuration'
-require 'jsonapi/association'
 require 'jsonapi/callbacks'
 
 module JSONAPI
@@ -37,19 +35,26 @@ module JSONAPI
     end
 
     def change(callback)
+      completed = false
+
       if @changing
         run_callbacks callback do
-          yield
+          completed = (yield == :completed)
         end
       else
         run_callbacks is_new? ? :create : :update do
           @changing = true
           run_callbacks callback do
-            yield
-            save if @save_needed || is_new?
+            completed = (yield == :completed)
+          end
+
+          if @save_needed || is_new?
+            completed = (save == :completed)
           end
         end
       end
+
+      return completed ? :completed : :accepted
     end
 
     def remove
@@ -100,7 +105,7 @@ module JSONAPI
     end
 
     # Override this on a resource to customize how the associated records
-    # are fetched for a model. Particularly helpful for authoriztion.
+    # are fetched for a model. Particularly helpful for authorization.
     def records_for(association_name, options = {})
       model.send association_name
     end
@@ -112,15 +117,42 @@ module JSONAPI
       end
     end
 
+    # Override this on a resource to return a different result code. Any
+    # value other than :completed will result in operations returning
+    # `:accepted`
+    #
+    # For example to return `:accepted` if your model does not immediately
+    # save resources to the database you could override `_save` as follows:
+    #
+    # ```
+    # def _save
+    #   super
+    #   return :accepted
+    # end
+    # ```
     def _save
-      @model.save!
-      @save_needed = false
-    rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotSaved => e
-      raise JSONAPI::Exceptions::ValidationErrors.new(e.record.errors.messages)
+      unless @model.valid?
+        raise JSONAPI::Exceptions::ValidationErrors.new(@model.errors.messages)
+      end
+
+      if defined? @model.save
+        saved = @model.save
+        unless saved
+          raise JSONAPI::Exceptions::SaveFailed.new
+        end
+      else
+        saved = true
+      end
+
+      @save_needed = !saved
+
+      return :completed
     end
 
     def _remove
       @model.destroy
+
+      return :completed
     end
 
     def _create_has_many_links(association_type, association_key_values)
@@ -137,6 +169,8 @@ module JSONAPI
           raise JSONAPI::Exceptions::HasManyRelationExists.new(association_key_value)
         end
       end
+
+      return :completed
     end
 
     def _replace_has_many_links(association_type, association_key_values)
@@ -144,6 +178,8 @@ module JSONAPI
 
       send("#{association.foreign_key}=", association_key_values)
       @save_needed = true
+
+      return :completed
     end
 
     def _replace_has_one_link(association_type, association_key_value)
@@ -151,12 +187,16 @@ module JSONAPI
 
       send("#{association.foreign_key}=", association_key_value)
       @save_needed = true
+
+      return :completed
     end
 
     def _remove_has_many_link(association_type, key)
       association = self.class._associations[association_type]
 
       @model.send(association.type).delete(key)
+
+      return :completed
     end
 
     def _remove_has_one_link(association_type)
@@ -164,6 +204,8 @@ module JSONAPI
 
       send("#{association.foreign_key}=", nil)
       @save_needed = true
+
+      return :completed
     end
 
     def _replace_fields(field_data)
@@ -189,6 +231,8 @@ module JSONAPI
       field_data[:has_many].each do |association_type, values|
         replace_has_many_links(association_type, values)
       end if field_data[:has_many]
+
+      return :completed
     end
 
     class << self
@@ -242,6 +286,10 @@ module JSONAPI
       def attribute(attr, options = {})
         check_reserved_attribute_name(attr)
 
+        if (attr.to_sym == :id) && (options[:format].nil?)
+          ActiveSupport::Deprecation.warn('Id without format is no longer supported. Please remove ids from attributes, or specify a format.')
+        end
+
         @_attributes ||= {}
         @_attributes[attr] = options
         define_method attr do
@@ -270,25 +318,40 @@ module JSONAPI
       end
 
       def filters(*attrs)
-        @_allowed_filters.merge(attrs)
+        @_allowed_filters.merge!(attrs.inject( Hash.new ) { |h, attr| h[attr] = {}; h })
       end
 
-      def filter(attr)
-        @_allowed_filters.add(attr.to_sym)
+      def filter(attr, *args)
+        @_allowed_filters[attr.to_sym] = args.extract_options!
       end
 
       def primary_key(key)
         @_primary_key = key.to_sym
       end
 
-      # Override in your resource to filter the updateable keys
-      def updateable_fields(context = nil)
-        _updateable_associations | _attributes.keys - [_primary_key]
+      # TODO: remove this after the createable_fields and updateable_fields are phased out
+      # :nocov:
+      def method_missing(method, *args)
+        if method.to_s.match /createable_fields/
+          ActiveSupport::Deprecation.warn("`createable_fields` is deprecated, please use `creatable_fields` instead")
+          self.creatable_fields(*args)
+        elsif method.to_s.match /updateable_fields/
+          ActiveSupport::Deprecation.warn("`updateable_fields` is deprecated, please use `updatable_fields` instead")
+          self.updatable_fields(*args)
+        else
+          super
+        end
+      end
+      # :nocov:
+
+      # Override in your resource to filter the updatable keys
+      def updatable_fields(context = nil)
+        _updatable_associations | _attributes.keys - [:id]
       end
 
-      # Override in your resource to filter the createable keys
-      def createable_fields(context = nil)
-        _updateable_associations | _attributes.keys
+      # Override in your resource to filter the creatable keys
+      def creatable_fields(context = nil)
+        _updatable_associations | _attributes.keys
       end
 
       # Override in your resource to filter the sortable keys
@@ -300,50 +363,86 @@ module JSONAPI
         _associations.keys | _attributes.keys
       end
 
-      def apply_pagination(records, paginator)
+      def apply_includes(records, directives)
+        records = records.includes(*directives.model_includes) if directives
+        records
+      end
+
+      def apply_pagination(records, paginator, order_options)
         if paginator
-          records = paginator.apply(records)
+          records = paginator.apply(records, order_options)
         end
         records
       end
 
       def apply_sort(records, order_options)
-        records.order(order_options)
+        if order_options.any?
+          records.order(order_options)
+        else
+          records
+        end
       end
 
-      def apply_filter(records, filter, value)
+      def apply_filter(records, filter, value, options = {})
         records.where(filter => value)
       end
 
-      def apply_filters(records, filters)
+      def apply_filters(records, filters, options = {})
         required_includes = []
-        filters.each do |filter, value|
-          if _associations.include?(filter)
-            if _associations[filter].is_a?(JSONAPI::Association::HasMany)
-              required_includes.push(filter)
-              records = apply_filter(records, "#{filter}.#{_associations[filter].primary_key}", value)
+
+        if filters
+          filters.each do |filter, value|
+            if _associations.include?(filter)
+              if _associations[filter].is_a?(JSONAPI::Association::HasMany)
+                required_includes.push(filter)
+                records = apply_filter(records, "#{filter}.#{_associations[filter].primary_key}", value, options)
+              else
+                records = apply_filter(records, "#{_associations[filter].foreign_key}", value, options)
+              end
             else
-              records = apply_filter(records, "#{_associations[filter].foreign_key}", value)
+              records = apply_filter(records, filter, value, options)
             end
-          else
-            records = apply_filter(records, filter, value)
           end
         end
-        records.includes(required_includes)
+
+        if required_includes.any?
+          records.includes(required_includes)
+        elsif records.respond_to? :to_ary
+          records
+        else
+          records.all
+        end
+      end
+
+      def filter_records(filters, options)
+        include_directives = options[:include_directives]
+
+        records = records(options)
+        records = apply_includes(records, include_directives)
+        apply_filters(records, filters, options)
+      end
+
+      def sort_records(records, order_options)
+        apply_sort(records, order_options)
+      end
+
+      def find_count(filters, options = {})
+        filter_records(filters, options).count
       end
 
       # Override this method if you have more complex requirements than this basic find method provides
       def find(filters, options = {})
         context = options[:context]
-        sort_criteria = options.fetch(:sort_criteria) { [] }
 
-        resources = []
+        records = filter_records(filters, options)
 
-        records = records(options)
-        records = apply_filters(records, filters)
-        records = apply_sort(records, construct_order_options(sort_criteria))
-        records = apply_pagination(records, options[:paginator])
+        sort_criteria = options.fetch(:sort_criteria) { [] }
+        order_options = construct_order_options(sort_criteria)
+        records = sort_records(records, order_options)
+
+        records = apply_pagination(records, options[:paginator], order_options)
 
+        resources = []
         records.each do |model|
           resources.push self.new(model, context)
         end
@@ -353,7 +452,10 @@ module JSONAPI
 
       def find_by_key(key, options = {})
         context = options[:context]
-        model = records(options).where({_primary_key => key}).first
+        include_directives = options[:include_directives]
+        records = records(options)
+        records = apply_includes(records, include_directives)
+        model = records.where({_primary_key => key}).first
         if model.nil?
           raise JSONAPI::Exceptions::RecordNotFound.new(key)
         end
@@ -394,7 +496,7 @@ module JSONAPI
       def verify_key(key, context = nil)
         key && Integer(key)
       rescue
-        raise JSONAPI::Exceptions::InvalidFieldValue.new(_primary_key, key)
+        raise JSONAPI::Exceptions::InvalidFieldValue.new(:id, key)
       end
 
       # override to allow for key processing and checking
@@ -419,13 +521,8 @@ module JSONAPI
         default_attribute_options.merge(@_attributes[attr])
       end
 
-      def _updateable_associations
-        associations = []
-
-        @_associations.each do |key, association|
-          associations.push(key)
-        end
-        associations
+      def _updatable_associations
+        @_associations.map { |key, association| key }
       end
 
       def _has_association?(type)
@@ -451,13 +548,13 @@ module JSONAPI
       end
 
       def _allowed_filters
-        !@_allowed_filters.nil? ? @_allowed_filters : Set.new([_primary_key])
+        !@_allowed_filters.nil? ? @_allowed_filters : { :id => {} }
       end
 
       def _resource_name_from_type(type)
         class_name = @@resource_types[type]
         if class_name.nil?
-          class_name = type.to_s.singularize.camelize + 'Resource'
+          class_name = "#{type.to_s.singularize}_resource".camelize
           @@resource_types[type] = class_name
         end
         return class_name
@@ -476,7 +573,7 @@ module JSONAPI
       end
 
       def _allowed_filter?(filter)
-        _allowed_filters.include?(filter)
+        !_allowed_filters[filter].nil?
       end
 
       def module_path
@@ -484,8 +581,11 @@ module JSONAPI
       end
 
       def construct_order_options(sort_params)
+        return {} unless sort_params
+
         sort_params.each_with_object({}) { |sort, order_hash|
-          order_hash[sort[:field]] = sort[:direction]
+          field = sort[:field] == 'id' ? _primary_key : sort[:field]
+          order_hash[field] = sort[:direction]
         }
       end
 
@@ -554,14 +654,16 @@ module JSONAPI
               resource_class = Resource.resource_for(self.class.module_path + type_name)
               filters = options.fetch(:filters, {})
               sort_criteria =  options.fetch(:sort_criteria, {})
-              paginator = options.fetch(:paginator, nil)
+              paginator = options[:paginator]
 
               resources = []
+
               if resource_class
                 records = public_send(associated_records_method_name)
-                records = self.class.apply_filters(records, filters)
-                records = self.class.apply_sort(records, self.class.construct_order_options(sort_criteria))
-                records = self.class.apply_pagination(records, paginator)
+                records = resource_class.apply_filters(records, filters, options)
+                order_options = self.class.construct_order_options(sort_criteria)
+                records = resource_class.apply_sort(records, order_options)
+                records = resource_class.apply_pagination(records, paginator, order_options)
                 records.each do |record|
                   resources.push resource_class.new(record, @context)
                 end
@@ -572,5 +674,6 @@ module JSONAPI
         end
       end
     end
+
   end
 end

data/lib/jsonapi/resource_controller.rb

@@ -1,238 +1,5 @@
-require 'jsonapi/resource_serializer'
-require 'action_controller'
-require 'jsonapi/exceptions'
-require 'jsonapi/error'
-require 'jsonapi/error_codes'
-require 'jsonapi/request'
-require 'jsonapi/operations_processor'
-require 'jsonapi/active_record_operations_processor'
-require 'csv'
-
 module JSONAPI
   class ResourceController < ActionController::Base
-    before_filter :ensure_correct_media_type, only: [:create, :update, :create_association, :update_association]
-    before_filter :setup_request
-    after_filter :setup_response
-
-    def index
-      serializer = JSONAPI::ResourceSerializer.new(resource_klass,
-                                                   include: @request.include,
-                                                   fields: @request.fields,
-                                                   base_url: base_url,
-                                                   key_formatter: key_formatter,
-                                                   route_formatter: route_formatter)
-
-      resource_records = resource_klass.find(resource_klass.verify_filters(@request.filters, context),
-                                             context: context,
-                                             sort_criteria: @request.sort_criteria,
-                                             paginator: @request.paginator)
-
-      render json: serializer.serialize_to_hash(resource_records)
-    rescue => e
-      handle_exceptions(e)
-    end
-
-    def show
-      serializer = JSONAPI::ResourceSerializer.new(resource_klass,
-                                                   include: @request.include,
-                                                   fields: @request.fields,
-                                                   base_url: base_url,
-                                                   key_formatter: key_formatter,
-                                                   route_formatter: route_formatter)
-
-      key = resource_klass.verify_key(params[resource_klass._primary_key], context)
-
-      resource_record = resource_klass.find_by_key(key, context: context)
-
-      render json: serializer.serialize_to_hash(resource_record)
-    rescue => e
-      handle_exceptions(e)
-    end
-
-    def show_association
-      association_type = params[:association]
-
-      parent_key = resource_klass.verify_key(params[resource_klass._as_parent_key], context)
-
-      parent_resource = resource_klass.find_by_key(parent_key, context: context)
-
-      association = resource_klass._association(association_type)
-
-      serializer = JSONAPI::ResourceSerializer.new(resource_klass,
-                                                   fields: @request.fields,
-                                                   base_url: base_url,
-                                                   key_formatter: key_formatter,
-                                                   route_formatter: route_formatter)
-
-      render json: serializer.serialize_to_links_hash(parent_resource, association)
-    rescue => e
-      handle_exceptions(e)
-    end
-
-    def create
-      process_request_operations
-    end
-
-    def create_association
-      process_request_operations
-    end
-
-    def update_association
-      process_request_operations
-    end
-
-    def update
-      process_request_operations
-    end
-
-    def destroy
-      process_request_operations
-    end
-
-    def destroy_association
-      process_request_operations
-    end
-
-    def get_related_resource
-      association_type = params[:association]
-      source_resource = @request.source_klass.find_by_key(@request.source_id, context: context)
-
-      serializer = JSONAPI::ResourceSerializer.new(@request.source_klass,
-                                                   include: @request.include,
-                                                   fields: @request.fields,
-                                                   base_url: base_url,
-                                                   key_formatter: key_formatter,
-                                                   route_formatter: route_formatter)
-
-      render json: serializer.serialize_to_hash(source_resource.send(association_type))
-    end
-
-    def get_related_resources
-      association_type = params[:association]
-      source_resource = @request.source_klass.find_by_key(@request.source_id, context: context)
-
-      related_resources = source_resource.send(association_type,
-                                               {
-                                                 filters:  @request.source_klass.verify_filters(@request.filters, context),
-                                                 sort_criteria: @request.sort_criteria,
-                                                 paginator: @request.paginator
-                                               })
-
-      serializer = JSONAPI::ResourceSerializer.new(@request.source_klass,
-                                                   include: @request.include,
-                                                   fields: @request.fields,
-                                                   base_url: base_url,
-                                                   key_formatter: key_formatter,
-                                                   route_formatter: route_formatter)
-
-      render json: serializer.serialize_to_hash(related_resources)
-    end
-
-    # Override this to use another operations processor
-    def create_operations_processor
-      JSONAPI::ActiveRecordOperationsProcessor.new
-    end
-
-    private
-    def resource_klass
-      @resource_klass ||= resource_klass_name.safe_constantize
-    end
-
-    def base_url
-      @base_url ||= request.protocol + request.host_with_port
-    end
-
-    def resource_klass_name
-      @resource_klass_name ||= "#{self.class.name.sub(/Controller$/, '').singularize}Resource"
-    end
-
-    def ensure_correct_media_type
-      unless request.content_type == JSONAPI::MEDIA_TYPE
-        raise JSONAPI::Exceptions::UnsupportedMediaTypeError.new(request.content_type)
-      end
-    rescue => e
-      handle_exceptions(e)
-    end
-
-    def setup_request
-      @request = JSONAPI::Request.new(params, {
-        context: context,
-        key_formatter: key_formatter
-      })
-      render_errors(@request.errors) unless @request.errors.empty?
-    rescue => e
-      handle_exceptions(e)
-    end
-
-    def setup_response
-      if response.body.size > 0
-        response.headers['Content-Type'] = JSONAPI::MEDIA_TYPE
-      end
-    end
-
-    # override to set context
-    def context
-      {}
-    end
-
-    # Control by setting in an initializer:
-    #     JSONAPI.configuration.json_key_format = :camelized_key
-    #     JSONAPI.configuration.route = :camelized_route
-    #
-    # Override if you want to set a per controller key format.
-    # Must return a class derived from KeyFormatter.
-    def key_formatter
-      JSONAPI.configuration.key_formatter
-    end
-
-    def route_formatter
-      JSONAPI.configuration.route_formatter
-    end
-
-    def render_errors(errors)
-      render(json: {errors: errors}, status: errors[0].status)
-    end
-
-    def process_request_operations
-      results   = create_operations_processor.process(@request)
-      errors    = results.select(&:has_errors?).flat_map(&:errors).compact
-      resources = results.reject(&:has_errors?).flat_map(&:resource).compact
-
-      status, json = case
-        when errors.any?
-          [errors[0].status, {errors: errors}]
-        when results.any? && resources.any?
-          res = resources.length > 1 ? resources : resources[0]
-          [results[0].code, processing_serializer.serialize_to_hash(res)]
-        else
-          [results[0].code, nil]
-      end
-
-      render status: status, json: json
-    rescue => e
-      handle_exceptions(e)
-    end
-
-    def processing_serializer
-      JSONAPI::ResourceSerializer.new(resource_klass,
-                                      include: @request.include,
-                                      fields: @request.fields,
-                                      base_url: base_url,
-                                      key_formatter: key_formatter,
-                                      route_formatter: route_formatter)
-    end
-
-    # override this to process other exceptions
-    # Note: Be sure to either call super(e) or handle JSONAPI::Exceptions::Error and raise unhandled exceptions
-    def handle_exceptions(e)
-      case e
-        when JSONAPI::Exceptions::Error
-          render_errors(e.errors)
-        else # raise all other exceptions
-          # :nocov:
-          raise e
-          # :nocov:
-      end
-    end
+    include JSONAPI::ActsAsResourceController
   end
 end