sanger-jsonapi-resources 0.1.0

data/lib/jsonapi/paginator.rb

@@ -0,0 +1,209 @@
+module JSONAPI
+  class Paginator
+    def initialize(_params)
+    end
+
+    def apply(_relation, _order_options)
+      # relation
+    end
+
+    def links_page_params(_options = {})
+      # :nocov:
+      {}
+      # :nocov:
+    end
+
+    class << self
+      def requires_record_count
+        # :nocov:
+        false
+        # :nocov:
+      end
+
+      def paginator_for(paginator)
+        paginator_class_name = "#{paginator.to_s.camelize}Paginator"
+        paginator_class_name.safe_constantize if paginator_class_name
+      end
+    end
+  end
+end
+
+class OffsetPaginator < JSONAPI::Paginator
+  attr_reader :limit, :offset
+
+  def initialize(params)
+    parse_pagination_params(params)
+    verify_pagination_params
+  end
+
+  def self.requires_record_count
+    true
+  end
+
+  def apply(relation, _order_options)
+    relation.offset(@offset).limit(@limit)
+  end
+
+  def links_page_params(options = {})
+    record_count = options[:record_count]
+    links_page_params = {}
+
+    links_page_params['first'] = {
+      'offset' => 0,
+      'limit' => @limit
+    }
+
+    if @offset > 0
+      previous_offset = @offset - @limit
+
+      previous_offset = 0 if previous_offset < 0
+
+      links_page_params['prev'] = {
+        'offset' => previous_offset,
+        'limit' => @limit
+      }
+    end
+
+    next_offset = @offset + @limit
+
+    unless next_offset >= record_count
+      links_page_params['next'] = {
+        'offset' => next_offset,
+        'limit' => @limit
+      }
+    end
+
+    if record_count
+      last_offset = record_count - @limit
+
+      last_offset = 0 if last_offset < 0
+
+      links_page_params['last'] = {
+        'offset' => last_offset,
+        'limit' => @limit
+      }
+    end
+
+    links_page_params
+  end
+
+  private
+
+  def parse_pagination_params(params)
+    if params.nil?
+      @offset = 0
+      @limit = JSONAPI.configuration.default_page_size
+    elsif params.is_a?(ActionController::Parameters)
+      validparams = params.permit(:offset, :limit)
+
+      @offset = validparams[:offset] ? validparams[:offset].to_i : 0
+      @limit = validparams[:limit] ? validparams[:limit].to_i : JSONAPI.configuration.default_page_size
+    else
+      fail JSONAPI::Exceptions::InvalidPageObject.new
+    end
+  rescue ActionController::UnpermittedParameters => e
+    raise JSONAPI::Exceptions::PageParametersNotAllowed.new(e.params)
+  end
+
+  def verify_pagination_params
+    if @limit < 1
+      fail JSONAPI::Exceptions::InvalidPageValue.new(:limit, @limit)
+    elsif @limit > JSONAPI.configuration.maximum_page_size
+      fail JSONAPI::Exceptions::InvalidPageValue.new(:limit, @limit,
+                                                     detail: "Limit exceeds maximum page size of #{JSONAPI.configuration.maximum_page_size}.")
+    end
+
+    if @offset < 0
+      fail JSONAPI::Exceptions::InvalidPageValue.new(:offset, @offset)
+    end
+  end
+end
+
+class PagedPaginator < JSONAPI::Paginator
+  attr_reader :size, :number
+
+  def initialize(params)
+    parse_pagination_params(params)
+    verify_pagination_params
+  end
+
+  def self.requires_record_count
+    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)
+  end
+
+  def links_page_params(options = {})
+    record_count = options[:record_count]
+    page_count = calculate_page_count(record_count)
+
+    links_page_params = {}
+
+    links_page_params['first'] = {
+      'number' => 1,
+      'size' => @size
+    }
+
+    if @number > 1
+      links_page_params['prev'] = {
+        'number' => @number - 1,
+        'size' => @size
+      }
+    end
+
+    unless @number >= page_count
+      links_page_params['next'] = {
+        'number' => @number + 1,
+        'size' => @size
+      }
+    end
+
+    if record_count
+      links_page_params['last'] = {
+        'number' => page_count == 0 ? 1 : page_count,
+        'size' => @size
+      }
+    end
+
+    links_page_params
+  end
+
+  private
+
+  def parse_pagination_params(params)
+    if params.nil?
+      @number = 1
+      @size = JSONAPI.configuration.default_page_size
+    elsif params.is_a?(ActionController::Parameters)
+      validparams = params.permit(:number, :size)
+
+      @size = validparams[:size] ? validparams[:size].to_i : JSONAPI.configuration.default_page_size
+      @number = validparams[:number] ? validparams[:number].to_i : 1
+    else
+      @size = JSONAPI.configuration.default_page_size
+      @number = params.to_i
+    end
+  rescue ActionController::UnpermittedParameters => e
+    raise JSONAPI::Exceptions::PageParametersNotAllowed.new(e.params)
+  end
+
+  def verify_pagination_params
+    if @size < 1
+      fail JSONAPI::Exceptions::InvalidPageValue.new(:size, @size)
+    elsif @size > JSONAPI.configuration.maximum_page_size
+      fail JSONAPI::Exceptions::InvalidPageValue.new(:size, @size,
+                                                     detail: "size exceeds maximum page size of #{JSONAPI.configuration.maximum_page_size}.")
+    end
+
+    if @number < 1
+      fail JSONAPI::Exceptions::InvalidPageValue.new(:number, @number)
+    end
+  end
+end

data/lib/jsonapi/processor.rb

@@ -0,0 +1,328 @@
+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_relationships,
+                                       :replace_to_many_relationships,
+                                       :remove_to_many_relationships,
+                                       :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)
+      find_options = {
+        context: context,
+        include_directives: include_directives,
+        sort_criteria: sort_criteria,
+        paginator: paginator,
+        fields: fields
+      }
+
+      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
+
+      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 ? 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)
+      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)
+
+      find_options = {
+        context: context,
+        include_directives: include_directives,
+        fields: fields
+      }
+
+      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
+
+      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]
+
+      # TODO Should fetch related_resource from cache if caching enabled
+      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]
+      include_directives = params[:include_directives]
+
+      source_resource ||= source_klass.find_by_key(source_id, context: context, fields: fields)
+
+      rel_opts = {
+        filters:  filters,
+        sort_criteria: sort_criteria,
+        paginator: paginator,
+        fields: fields,
+        context: context,
+        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
+
+      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_relationships
+      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_relationships
+      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_relationships
+      resource_id = params[:resource_id]
+      relationship_type = params[:relationship_type].to_sym
+      associated_keys = params[:associated_keys]
+
+      resource = resource_klass.find_by_key(resource_id, context: context)
+
+      complete = true
+      associated_keys.each do |key|
+        result = resource.remove_to_many_link(relationship_type, key)
+        if complete && result != :completed
+          complete = false
+        end
+      end
+      return JSONAPI::OperationResult.new(complete ? :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

@@ -0,0 +1,94 @@
+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
+
+    def initialize(name, options = {})
+      @name = name.to_s
+      @options = options
+      @acts_as_set = options.fetch(:acts_as_set, false) == true
+      @foreign_key = options[:foreign_key] ? options[:foreign_key].to_sym : nil
+      @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
+      @eager_load_on_include = options.fetch(:eager_load_on_include, true) == true
+    end
+
+    alias_method :polymorphic?, :polymorphic
+
+    def primary_key
+      @primary_key ||= resource_klass._primary_key
+    end
+
+    def resource_klass
+      @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
+          # :nocov:
+          @relation_name
+          # :nocov:
+        when String
+          @relation_name.to_sym
+        when Proc
+          @relation_name.call(options)
+      end
+    end
+
+    def type_for_source(source)
+      if polymorphic?
+        resource = source.public_send(name)
+        resource.class._type if resource
+      else
+        type
+      end
+    end
+
+    def belongs_to?
+      false
+    end
+
+    class ToOne < Relationship
+      attr_reader :foreign_key_on
+
+      def initialize(name, options = {})
+        super
+        @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)
+      end
+
+      def belongs_to?
+        foreign_key_on == :self
+      end
+
+      def polymorphic_type
+        "#{name}_type" if polymorphic?
+      end
+    end
+
+    class ToMany < Relationship
+      attr_reader :reflect, :inverse_relationship
+
+      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
+      end
+    end
+  end
+end