jsonapi-resources 0.3.3 → 0.4.0

data/lib/jsonapi/operation.rb

@@ -1,162 +1,282 @@
 module JSONAPI
   class Operation
+    attr_reader :resource_klass, :options, :transactional
 
-    attr_reader :resource_klass
-
-    def initialize(resource_klass)
+    def initialize(resource_klass, options = {})
       @resource_klass = resource_klass
+      @options = options
+      @transactional = true
+    end
+
+    def apply(context)
+    end
+  end
+
+  class FindOperation < Operation
+    attr_reader :filters, :include_directives, :sort_criteria, :paginator
+
+    def initialize(resource_klass, options = {})
+      @filters = options[:filters]
+      @include_directives = options[:include_directives]
+      @sort_criteria = options.fetch(:sort_criteria, [])
+      @paginator = options[:paginator]
+      super(resource_klass, false)
+    end
+
+    def apply(context)
+      resource_records = @resource_klass.find(@resource_klass.verify_filters(@filters, context),
+                                             context: context,
+                                             include_directives: @include_directives,
+                                             sort_criteria: @sort_criteria,
+                                             paginator: @paginator)
+
+      return JSONAPI::ResourcesOperationResult.new(:ok, resource_records)
+
+    rescue JSONAPI::Exceptions::Error => e
+      return JSONAPI::ErrorsOperationResult.new(e.errors[0].code, e.errors)
+    end
+  end
+
+  class ShowOperation < Operation
+    attr_reader :id, :include_directives
+
+    def initialize(resource_klass, options = {})
+      @id = options.fetch(:id)
+      @include_directives = options[:include_directives]
+      @transactional = false
+      super(resource_klass, options)
+    end
+
+    def apply(context)
+      key = @resource_klass.verify_key(@id, context)
+
+      resource_record = resource_klass.find_by_key(key,
+                                                   context: context,
+                                                   include_directives: @include_directives)
+
+      return JSONAPI::ResourceOperationResult.new(:ok, resource_record)
+
+    rescue JSONAPI::Exceptions::Error => e
+      return JSONAPI::ErrorsOperationResult.new(e.errors[0].code, e.errors)
+    end
+  end
+
+  class ShowAssociationOperation < Operation
+    attr_reader :parent_key, :association_type
+
+    def initialize(resource_klass, options = {})
+      @parent_key = options.fetch(:parent_key)
+      @association_type = options.fetch(:association_type)
+      @transactional = false
+      super(resource_klass, options)
     end
 
     def apply(context)
+      parent_resource = resource_klass.find_by_key(@parent_key, context: context)
+
+      return JSONAPI::LinksObjectOperationResult.new(:ok,
+                                                     parent_resource,
+                                                     resource_klass._association(@association_type))
+
+    rescue JSONAPI::Exceptions::Error => e
+      return JSONAPI::ErrorsOperationResult.new(e.errors[0].code, e.errors)
+    end
+  end
+
+  class ShowRelatedResourceOperation < Operation
+    attr_reader :source_klass, :source_id, :association_type
+
+    def initialize(resource_klass, options = {})
+      @source_klass = options.fetch(:source_klass)
+      @source_id = options.fetch(:source_id)
+      @association_type = options.fetch(:association_type)
+      @transactional = false
+      super(resource_klass, options)
+    end
+
+    def apply(context)
+      source_resource = @source_klass.find_by_key(@source_id, context: context)
+
+      related_resource = source_resource.send(@association_type)
+
+      return JSONAPI::ResourceOperationResult.new(:ok, related_resource)
+
+    rescue JSONAPI::Exceptions::Error => e
+      return JSONAPI::ErrorsOperationResult.new(e.errors[0].code, e.errors)
+    end
+  end
+
+  class ShowRelatedResourcesOperation < Operation
+    attr_reader :source_klass, :source_id, :association_type, :filters, :sort_criteria, :paginator
+
+    def initialize(resource_klass, options = {})
+      @source_klass = options.fetch(:source_klass)
+      @source_id = options.fetch(:source_id)
+      @association_type = options.fetch(:association_type)
+      @filters = options[:filters]
+      @sort_criteria = options[:sort_criteria]
+      @paginator = options[:paginator]
+      @transactional = false
+      super(resource_klass, options)
+    end
+
+    def apply(context)
+      source_resource = @source_klass.find_by_key(@source_id, context: context)
+
+      related_resource = source_resource.send(@association_type,
+                                              {
+                                                filters:  @filters,
+                                                sort_criteria: @sort_criteria,
+                                                paginator: @paginator
+                                              })
+
+      return JSONAPI::ResourceOperationResult.new(:ok, related_resource)
+
+    rescue JSONAPI::Exceptions::Error => e
+      return JSONAPI::ErrorsOperationResult.new(e.errors[0].code, e.errors)
     end
   end
 
   class CreateResourceOperation < Operation
-    attr_reader :values
+    attr_reader :data
 
-    def initialize(resource_klass, values = {})
-      @values = values
-      super(resource_klass)
+    def initialize(resource_klass, options = {})
+      @data = options.fetch(:data)
+      super(resource_klass, options)
     end
 
     def apply(context)
       resource = @resource_klass.create(context)
-      resource.replace_fields(@values)
+      result = resource.replace_fields(@data)
 
-      return JSONAPI::OperationResult.new(:created, resource)
+      return JSONAPI::ResourceOperationResult.new((result == :completed ? :created : :accepted), resource)
 
     rescue JSONAPI::Exceptions::Error => e
-      return JSONAPI::OperationResult.new(e.errors[0].code, nil, e.errors)
+      return JSONAPI::ErrorsOperationResult.new(e.errors[0].code, e.errors)
     end
   end
 
   class RemoveResourceOperation < Operation
     attr_reader :resource_id
-    def initialize(resource_klass, resource_id)
-      @resource_id = resource_id
-      super(resource_klass)
+    def initialize(resource_klass, options = {})
+      @resource_id = options.fetch(:resource_id)
+      super(resource_klass, options)
     end
 
     def apply(context)
       resource = @resource_klass.find_by_key(@resource_id, context: context)
-      resource.remove
+      result = resource.remove
 
-      return JSONAPI::OperationResult.new(:no_content)
+      return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted)
 
-    rescue ActiveRecord::DeleteRestrictionError => e
-      record_locked_error = JSONAPI::Exceptions::RecordLocked.new(e.message)
-      return JSONAPI::OperationResult.new(record_locked_error.errors[0].code, nil, record_locked_error.errors)
     rescue JSONAPI::Exceptions::Error => e
-      return JSONAPI::OperationResult.new(e.errors[0].code, nil, e.errors)
+      return JSONAPI::ErrorsOperationResult.new(e.errors[0].code, e.errors)
     end
   end
 
   class ReplaceFieldsOperation < Operation
-    attr_reader :values, :resource_id
+    attr_reader :data, :resource_id
 
-    def initialize(resource_klass, resource_id, values)
-      @resource_id = resource_id
-      @values = values
-      super(resource_klass)
+    def initialize(resource_klass, options = {})
+      @resource_id = options.fetch(:resource_id)
+      @data = options.fetch(:data)
+      super(resource_klass, options)
     end
 
     def apply(context)
       resource = @resource_klass.find_by_key(@resource_id, context: context)
-      resource.replace_fields(values)
+      result = resource.replace_fields(data)
 
-      return JSONAPI::OperationResult.new(:ok, resource)
+      return JSONAPI::ResourceOperationResult.new(result == :completed ? :ok : :accepted, resource)
     end
   end
 
   class ReplaceHasOneAssociationOperation < Operation
     attr_reader :resource_id, :association_type, :key_value
 
-    def initialize(resource_klass, resource_id, association_type, key_value)
-      @resource_id = resource_id
-      @key_value = key_value
-      @association_type = association_type.to_sym
-      super(resource_klass)
+    def initialize(resource_klass, options = {})
+      @resource_id = options.fetch(:resource_id)
+      @key_value = options.fetch(:key_value)
+      @association_type = options.fetch(:association_type).to_sym
+      super(resource_klass, options)
     end
 
     def apply(context)
       resource = @resource_klass.find_by_key(@resource_id, context: context)
-      resource.replace_has_one_link(@association_type, @key_value)
+      result = resource.replace_has_one_link(@association_type, @key_value)
 
-      return JSONAPI::OperationResult.new(:no_content)
+      return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted)
     end
   end
 
   class CreateHasManyAssociationOperation < Operation
-    attr_reader :resource_id, :association_type, :key_values
+    attr_reader :resource_id, :association_type, :data
 
-    def initialize(resource_klass, resource_id, association_type, key_values)
-      @resource_id = resource_id
-      @key_values = key_values
-      @association_type = association_type.to_sym
-      super(resource_klass)
+    def initialize(resource_klass, options)
+      @resource_id = options.fetch(:resource_id)
+      @data = options.fetch(:data)
+      @association_type = options.fetch(:association_type).to_sym
+      super(resource_klass, options)
     end
 
     def apply(context)
       resource = @resource_klass.find_by_key(@resource_id, context: context)
-      resource.create_has_many_links(@association_type, @key_values)
+      result = resource.create_has_many_links(@association_type, @data)
 
-      return JSONAPI::OperationResult.new(:no_content)
+      return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted)
     end
   end
 
   class ReplaceHasManyAssociationOperation < Operation
-    attr_reader :resource_id, :association_type, :key_values
+    attr_reader :resource_id, :association_type, :data
 
-    def initialize(resource_klass, resource_id, association_type, key_values)
-      @resource_id = resource_id
-      @key_values = key_values
-      @association_type = association_type.to_sym
-      super(resource_klass)
+    def initialize(resource_klass, options)
+      @resource_id = options.fetch(:resource_id)
+      @data = options.fetch(:data)
+      @association_type = options.fetch(:association_type).to_sym
+      super(resource_klass, options)
     end
 
     def apply(context)
       resource = @resource_klass.find_by_key(@resource_id, context: context)
-      resource.replace_has_many_links(@association_type, @key_values)
+      result = resource.replace_has_many_links(@association_type, @data)
 
-      return JSONAPI::OperationResult.new(:no_content)
+      return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted)
     end
   end
 
   class RemoveHasManyAssociationOperation < Operation
     attr_reader :resource_id, :association_type, :associated_key
 
-    def initialize(resource_klass, resource_id, association_type, associated_key)
-      @resource_id = resource_id
-      @associated_key = associated_key
-      @association_type = association_type.to_sym
-      super(resource_klass)
+    def initialize(resource_klass, options)
+      @resource_id = options.fetch(:resource_id)
+      @associated_key = options.fetch(:associated_key)
+      @association_type = options.fetch(:association_type).to_sym
+      super(resource_klass, options)
     end
 
     def apply(context)
       resource = @resource_klass.find_by_key(@resource_id, context: context)
-      resource.remove_has_many_link(@association_type, @associated_key)
-
-      return JSONAPI::OperationResult.new(:no_content)
+      result = resource.remove_has_many_link(@association_type, @associated_key)
 
-    rescue ActiveRecord::RecordNotFound => e
-      raise JSONAPI::Exceptions::RecordNotFound.new(@associated_key)
+      return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted)
     end
   end
 
   class RemoveHasOneAssociationOperation < Operation
     attr_reader :resource_id, :association_type
 
-    def initialize(resource_klass, resource_id, association_type)
-      @resource_id = resource_id
-      @association_type = association_type.to_sym
-      super(resource_klass)
+    def initialize(resource_klass, options)
+      @resource_id = options.fetch(:resource_id)
+      @association_type = options.fetch(:association_type).to_sym
+      super(resource_klass, options)
     end
 
     def apply(context)
       resource = @resource_klass.find_by_key(@resource_id, context: context)
-      resource.remove_has_one_link(@association_type)
+      result = resource.remove_has_one_link(@association_type)
 
-      return JSONAPI::OperationResult.new(:no_content)
+      return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted)
     end
   end
 end

data/lib/jsonapi/operation_result.rb

@@ -1,15 +1,48 @@
 module JSONAPI
   class OperationResult
-    attr_accessor :code, :errors, :resource
+    attr_accessor :code
+    attr_accessor :meta
 
-    def initialize(code, resource = nil, errors = [])
+    def initialize(code)
       @code = code
-      @resource = resource
+      @meta = {}
+    end
+  end
+
+  class ErrorsOperationResult < OperationResult
+    attr_accessor :errors
+
+    def initialize(code, errors)
       @errors = errors
+      super(code)
+    end
+  end
+
+  class ResourceOperationResult < OperationResult
+    attr_accessor :resource
+
+    def initialize(code, resource)
+      @resource = resource
+      super(code)
+    end
+  end
+
+  class ResourcesOperationResult < OperationResult
+    attr_accessor :resources
+
+    def initialize(code, resources)
+      @resources = resources
+      super(code)
     end
+  end
+
+  class LinksObjectOperationResult < OperationResult
+    attr_accessor :parent_resource, :association
 
-    def has_errors?
-      errors.count > 0
+    def initialize(code, parent_resource, association)
+      @parent_resource = parent_resource
+      @association = association
+      super(code)
     end
   end
 end

data/lib/jsonapi/operation_results.rb

@@ -0,0 +1,33 @@
+module JSONAPI
+  class OperationResults
+    attr_accessor :results
+    attr_accessor :meta
+
+    def initialize
+      @results = []
+      @has_errors = false
+      @meta = {}
+    end
+
+    def add_result(result)
+      @has_errors = true if result.is_a?(JSONAPI::ErrorsOperationResult)
+      @results.push(result)
+    end
+
+    def has_errors?
+      @has_errors
+    end
+
+    def all_errors
+      errors = []
+      if @has_errors
+        @results.each do |result|
+          if result.is_a?(JSONAPI::ErrorsOperationResult)
+            errors.concat(result.errors)
+          end
+        end
+      end
+      errors
+    end
+  end
+end

data/lib/jsonapi/operations_processor.rb

@@ -1,30 +1,63 @@
-require 'jsonapi/operation_result'
-require 'jsonapi/callbacks'
-
 module JSONAPI
   class OperationsProcessor
     include Callbacks
-    define_jsonapi_resources_callbacks :operation, :operations
+    define_jsonapi_resources_callbacks :operation,
+                                       :operations,
+                                       :find_operation,
+                                       :show_operation,
+                                       :show_association_operation,
+                                       :show_related_resource_operation,
+                                       :show_related_resources_operation,
+                                       :create_resource_operation,
+                                       :remove_resource_operation,
+                                       :replace_fields_operation,
+                                       :replace_has_one_association_operation,
+                                       :create_has_many_association_operation,
+                                       :replace_has_many_association_operation,
+                                       :remove_has_many_association_operation,
+                                       :remove_has_one_association_operation
+
+    class << self
+      def operations_processor_for(operations_processor)
+        operations_processor_class_name = "#{operations_processor.to_s.camelize}OperationsProcessor"
+        operations_processor_class_name.safe_constantize
+      end
+    end
 
     def process(request)
-      @results = []
+      @results = JSONAPI::OperationResults.new
       @request = request
       @context = request.context
       @operations = request.operations
 
+      # 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
+      if @operations.length > 1
+        @operations.each do |operation|
+          @transactional = @transactional | operation.transactional
+        end
+      end
+
       run_callbacks :operations do
         transaction do
+          @operations_meta = {}
           @operations.each do |operation|
             @operation = operation
-            @result = nil
+            @operation_meta = {}
             run_callbacks :operation do
-              @result = @operation.apply(@context)
-              @results.push(@result)
-              if @result.has_errors?
+              @result = nil
+              run_callbacks @operation.class.name.demodulize.underscore.to_sym do
+                @result = process_operation(@operation)
+              end
+              @result.meta.merge!(@operation_meta)
+              @results.add_result(@result)
+              if @results.has_errors?
                 rollback
               end
             end
           end
+          @results.meta = @operations_meta
         end
       end
       @results
@@ -41,5 +74,12 @@ module JSONAPI
 
     def rollback
     end
+
+    def process_operation(operation)
+      operation.apply(@context)
+    end
   end
+end
+
+class BasicOperationsProcessor < JSONAPI::OperationsProcessor
 end