jsonapi-resources 0.7.1.beta1 → 0.7.1.beta2

data/lib/jsonapi/operation_dispatcher.rb

@@ -0,0 +1,87 @@
+module JSONAPI
+  class OperationDispatcher
+
+    def initialize(transaction: lambda { |&block| block.yield },
+                   rollback: lambda { },
+                   server_error_callbacks: [])
+
+      @transaction = transaction
+      @rollback = rollback
+      @server_error_callbacks = server_error_callbacks
+    end
+
+    def process(operations)
+      results = JSONAPI::OperationResults.new
+
+      # Use transactions if more than one operation and if one of the operations can be transactional
+      # Even if transactional transactions won't be used unless the derived OperationsProcessor supports them.
+      transactional = false
+      operations.each do |operation|
+        transactional |= operation.transactional?
+      end
+
+      transaction(transactional) do
+        # Links and meta data global to the set of operations
+        operations_meta = {}
+        operations_links = {}
+        operations.each do |operation|
+          results.add_result(process_operation(operation))
+          rollback(transactional) if results.has_errors?
+        end
+        results.meta = operations_meta
+        results.links = operations_links
+      end
+      results
+    end
+
+    private
+
+    def transaction(transactional)
+      if transactional
+        @transaction.call do
+          yield
+        end
+      else
+        yield
+      end
+    end
+
+    def rollback(transactional)
+      if transactional
+        @rollback.call
+      end
+    end
+
+    def process_operation(operation)
+      with_default_handling do 
+        operation.process
+      end        
+    end
+
+    def with_default_handling(&block)
+      block.yield
+    rescue => e
+      if JSONAPI.configuration.exception_class_whitelisted?(e)
+        raise e
+      else
+        @server_error_callbacks.each { |callback|
+          safe_run_callback(callback, e)
+        }
+
+        internal_server_error = JSONAPI::Exceptions::InternalServerError.new(e)
+        Rails.logger.error { "Internal Server Error: #{e.message} #{e.backtrace.join("\n")}" }
+        return JSONAPI::ErrorsOperationResult.new(internal_server_error.errors[0].code, internal_server_error.errors)
+      end
+    end
+
+    def safe_run_callback(callback, error)
+      begin 
+        callback.call(error)
+      rescue => e
+        Rails.logger.error { "Error in error handling callback: #{e.message} #{e.backtrace.join("\n")}" }
+        internal_server_error = JSONAPI::Exceptions::InternalServerError.new(e)
+        return JSONAPI::ErrorsOperationResult.new(internal_server_error.errors[0].code, internal_server_error.errors)
+      end
+    end
+  end
+end

data/lib/jsonapi/operation_result.rb

@@ -32,12 +32,13 @@ module JSONAPI
   end
 
   class ResourcesOperationResult < OperationResult
-    attr_accessor :resources, :pagination_params, :record_count
+    attr_accessor :resources, :pagination_params, :record_count, :page_count
 
     def initialize(code, resources, options = {})
       @resources = resources
       @pagination_params = options.fetch(:pagination_params, {})
       @record_count = options[:record_count]
+      @page_count = options[:page_count]
       super(code, options)
     end
   end

data/lib/jsonapi/paginator.rb

@@ -58,7 +58,7 @@ class OffsetPaginator < JSONAPI::Paginator
 
       previous_offset = 0 if previous_offset < 0
 
-      links_page_params['previous'] = {
+      links_page_params['prev'] = {
         'offset' => previous_offset,
         'limit' => @limit
       }
@@ -131,6 +131,10 @@ class PagedPaginator < JSONAPI::Paginator
     true
   end
 
+  def calculate_page_count(record_count)
+    (record_count / @size.to_f).ceil
+  end
+
   def apply(relation, _order_options)
     offset = (@number - 1) * @size
     relation.offset(offset).limit(@size)
@@ -138,7 +142,7 @@ class PagedPaginator < JSONAPI::Paginator
 
   def links_page_params(options = {})
     record_count = options[:record_count]
-    page_count = (record_count / @size.to_f).ceil
+    page_count = calculate_page_count(record_count)
 
     links_page_params = {}
 

data/lib/jsonapi/processor.rb

@@ -0,0 +1,283 @@
+module JSONAPI
+  class Processor
+    include Callbacks
+    define_jsonapi_resources_callbacks :find,
+                                       :show,
+                                       :show_relationship,
+                                       :show_related_resource,
+                                       :show_related_resources,
+                                       :create_resource,
+                                       :remove_resource,
+                                       :replace_fields,
+                                       :replace_to_one_relationship,
+                                       :replace_polymorphic_to_one_relationship,
+                                       :create_to_many_relationship,
+                                       :replace_to_many_relationship,
+                                       :remove_to_many_relationship,
+                                       :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)
+      @resource_klass = resource_klass
+      @operation_type = operation_type
+      @params = params
+      @context = params[:context]
+      @result = nil
+      @result_options = {}
+    end
+
+    def process
+      run_callbacks :operation do
+        run_callbacks operation_type do
+          @result = send(operation_type)
+        end
+      end
+
+    rescue JSONAPI::Exceptions::Error => e
+      @result = JSONAPI::ErrorsOperationResult.new(e.errors[0].code, e.errors)
+    end
+
+    def find
+      filters = params[:filters]
+      include_directives = params[:include_directives]
+      sort_criteria = params.fetch(:sort_criteria, [])
+      paginator = params[:paginator]
+      fields = params[:fields]
+
+      verified_filters = resource_klass.verify_filters(filters, context)
+      resource_records = resource_klass.find(verified_filters,
+                                             context: context,
+                                             include_directives: include_directives,
+                                             sort_criteria: sort_criteria,
+                                             paginator: paginator,
+                                             fields: fields)
+
+      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)
+      end
+
+      if (JSONAPI.configuration.top_level_meta_include_page_count && page_options[:record_count])
+        page_options[:page_count] = paginator.calculate_page_count(page_options[:record_count])
+      end
+
+      if JSONAPI.configuration.top_level_links_include_pagination && paginator
+        page_options[:pagination_params] = paginator.links_page_params(page_options)
+      end
+
+      return JSONAPI::ResourcesOperationResult.new(:ok, resource_records, page_options)
+    end
+
+    def show
+      include_directives = params[:include_directives]
+      fields = params[:fields]
+      id = params[:id]
+
+      key = resource_klass.verify_key(id, context)
+
+      resource_record = resource_klass.find_by_key(key,
+                                                   context: context,
+                                                   include_directives: include_directives,
+                                                   fields: fields)
+
+      return JSONAPI::ResourceOperationResult.new(:ok, resource_record)
+    end
+
+    def show_relationship
+      parent_key = params[:parent_key]
+      relationship_type = params[:relationship_type].to_sym
+
+      parent_resource = resource_klass.find_by_key(parent_key, context: context)
+
+      return JSONAPI::LinksObjectOperationResult.new(:ok,
+                                                     parent_resource,
+                                                     resource_klass._relationship(relationship_type))
+    end
+
+    def show_related_resource
+      source_klass = params[:source_klass]
+      source_id = params[:source_id]
+      relationship_type = params[:relationship_type].to_sym
+      fields = params[:fields]
+
+      source_resource = source_klass.find_by_key(source_id, context: context, fields: fields)
+
+      related_resource = source_resource.public_send(relationship_type)
+
+      return JSONAPI::ResourceOperationResult.new(:ok, related_resource)
+    end
+
+    def show_related_resources
+      source_klass = params[:source_klass]
+      source_id = params[:source_id]
+      relationship_type = params[:relationship_type]
+      filters = params[:filters]
+      sort_criteria = params[:sort_criteria]
+      paginator = params[:paginator]
+      fields = params[:fields]
+
+      source_resource ||= source_klass.find_by_key(source_id, context: context, fields: fields)
+
+      related_resources = source_resource.public_send(relationship_type,
+                                                      filters:  filters,
+                                                      sort_criteria: sort_criteria,
+                                                      paginator: paginator,
+                                                      fields: fields)
+
+      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)
+
+        record_count = resource_klass.count_records(records)
+      end
+
+      if (JSONAPI.configuration.top_level_meta_include_page_count && record_count)
+        page_count = paginator.calculate_page_count(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)
+    end
+
+    def create_resource
+      data = params[:data]
+      resource = resource_klass.create(context)
+      result = resource.replace_fields(data)
+
+      return JSONAPI::ResourceOperationResult.new((result == :completed ? :created : :accepted), resource)
+    end
+
+    def remove_resource
+      resource_id = params[:resource_id]
+
+      resource = resource_klass.find_by_key(resource_id, context: context)
+      result = resource.remove
+
+      return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted)
+    end
+
+    def replace_fields
+      resource_id = params[:resource_id]
+      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)
+    end
+
+    def replace_to_one_relationship
+      resource_id = params[:resource_id]
+      relationship_type = params[:relationship_type].to_sym
+      key_value = params[:key_value]
+
+      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)
+    end
+
+    def replace_polymorphic_to_one_relationship
+      resource_id = params[:resource_id]
+      relationship_type = params[:relationship_type].to_sym
+      key_value = params[:key_value]
+      key_type = params[:key_type]
+
+      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)
+    end
+
+    def create_to_many_relationship
+      resource_id = params[:resource_id]
+      relationship_type = params[:relationship_type].to_sym
+      data = params[:data]
+
+      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)
+    end
+
+    def replace_to_many_relationship
+      resource_id = params[:resource_id]
+      relationship_type = params[:relationship_type].to_sym
+      data = params.fetch(:data)
+
+      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)
+    end
+
+    def remove_to_many_relationship
+      resource_id = params[:resource_id]
+      relationship_type = params[:relationship_type].to_sym
+      associated_key = params[:associated_key]
+
+      resource = resource_klass.find_by_key(resource_id, context: context)
+      result = resource.remove_to_many_link(relationship_type, associated_key)
+
+      return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted)
+    end
+
+    def remove_to_one_relationship
+      resource_id = params[:resource_id]
+      relationship_type = params[:relationship_type].to_sym
+
+      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)
+    end
+  end
+end

data/lib/jsonapi/relationship.rb

@@ -1,6 +1,6 @@
 module JSONAPI
   class Relationship
-    attr_reader :acts_as_set, :foreign_key, :type, :options, :name,
+    attr_reader :acts_as_set, :foreign_key, :options, :name,
                 :class_name, :polymorphic, :always_include_linkage_data,
                 :parent_resource
 
@@ -22,13 +22,17 @@ module JSONAPI
     end
 
     def resource_klass
-      @resource_klass = @parent_resource.resource_for(@class_name)
+      @resource_klass ||= @parent_resource.resource_for(@class_name)
     end
 
     def table_name
       @table_name ||= resource_klass._table_name
     end
 
+    def type
+      @type ||= resource_klass._type.to_sym
+    end
+
     def relation_name(options)
       case @relation_name
         when Symbol
@@ -61,7 +65,6 @@ module JSONAPI
       def initialize(name, options = {})
         super
         @class_name = options.fetch(:class_name, name.to_s.camelize)
-        @type = class_name.underscore.pluralize.to_sym
         @foreign_key ||= "#{name}_id".to_sym
         @foreign_key_on = options.fetch(:foreign_key_on, :self)
       end
@@ -79,7 +82,6 @@ module JSONAPI
       def initialize(name, options = {})
         super
         @class_name = options.fetch(:class_name, name.to_s.camelize.singularize)
-        @type = class_name.underscore.pluralize.to_sym
         @foreign_key ||= "#{name.to_s.singularize}_ids".to_sym
       end
     end