graphiti-rb 1.0.alpha.1

data/lib/graphiti/scoping/paginate.rb

@@ -0,0 +1,87 @@
+module Graphiti
+  # Apply pagination logic to the scope
+  #
+  # If the user requests a page size greater than +MAX_PAGE_SIZE+,
+  # a +Graphiti::Errors::UnsupportedPageSize+ error will be raised.
+  #
+  # Notably, this will not fire when the `default: false` option is passed.
+  # This is the case for sideloads - if the user requests "give me the post
+  # and its comments", we shouldn't implicitly limit those comments to 20.
+  # *BUT* if the user requests, "give me the post and 3 of its comments", we
+  # *should* honor that pagination.
+  #
+  # This can be confusing because there are also 'default' and 'customized'
+  # pagination procs. The default comes 'for free'. Customized pagination
+  # looks like
+  #
+  #   class PostResource < ApplicationResource
+  #     paginate do |scope, current_page, per_page|
+  #       # ... the custom logic ...
+  #     end
+  #   end
+  #
+  # We should use the default unless the user has customized.
+  # @see Resource.paginate
+  class Scoping::Paginate < Scoping::Base
+    MAX_PAGE_SIZE = 1_000
+
+    # Apply the pagination logic. Raise error if over the max page size.
+    # @return the scope object we are chaining/modifying
+    def apply
+      if size > MAX_PAGE_SIZE
+        raise Graphiti::Errors::UnsupportedPageSize
+          .new(size, MAX_PAGE_SIZE)
+      elsif requested? && @opts[:sideload_parent_length].to_i > 1
+        raise Graphiti::Errors::UnsupportedPagination
+      else
+        super
+      end
+    end
+
+    # We want to apply this logic unless we've explicitly received the
+    # +default: false+ option. In that case, only apply if pagination
+    # was explicitly specified in the request.
+    #
+    # @return [Boolean] should we apply this logic?
+    def apply?
+      if @opts[:default_paginate] == false
+        requested?
+      else
+        true
+      end
+    end
+
+    # @return [Proc, Nil] the custom pagination proc
+    def custom_scope
+      resource.pagination
+    end
+
+    # Apply default pagination proc via the Resource adapter
+    def apply_standard_scope
+      resource.adapter.paginate(@scope, number, size)
+    end
+
+    # Apply the custom pagination proc
+    def apply_custom_scope
+      custom_scope.call(@scope, number, size, resource.context)
+    end
+
+    private
+
+    def requested?
+      not [page_param[:size], page_param[:number]].all?(&:nil?)
+    end
+
+    def page_param
+      @page_param ||= (query_hash[:page] || {})
+    end
+
+    def number
+      (page_param[:number] || 1).to_i
+    end
+
+    def size
+      (page_param[:size] || resource.default_page_size).to_i
+    end
+  end
+end

data/lib/graphiti/scoping/sort.rb

@@ -0,0 +1,64 @@
+module Graphiti
+  # Apply sorting logic to the scope.
+  #
+  # By default, sorting comes 'for free'. To specify a custom sorting proc:
+  #
+  #   class PostResource < ApplicationResource
+  #     sort do |scope, att, dir|
+  #       int = dir == :desc ? -1 : 1
+  #       scope.sort_by { |x| x[att] * int }
+  #     end
+  #   end
+  #
+  # The sorting proc will be called once for each sort att/dir requested.
+  # @see Resource.sort
+  class Scoping::Sort < Scoping::Base
+    # @return [Proc, Nil] The custom proc specified by Resource DSL
+    def custom_scope
+      resource.sort_all
+    end
+
+    # Apply default scope logic via Resource adapter
+    # @return the scope we are chaining/modifying
+    def apply_standard_scope
+      each_sort do |attribute, direction|
+        if sort = resource.sorts[attribute]
+          @scope = sort.call(@scope, direction)
+        else
+          @scope = resource.adapter.order(@scope, attribute, direction)
+        end
+      end
+      @scope
+    end
+
+    # Apply custom scoping proc configured via Resource DSL
+    # @return the scope we are chaining/modifying
+    def apply_custom_scope
+      each_sort do |attribute, direction|
+        @scope = custom_scope
+          .call(@scope, attribute, direction, resource.context)
+      end
+      @scope
+    end
+
+    private
+
+    def each_sort
+      sort_param.each do |sort_hash|
+        attribute = sort_hash.keys.first
+        direction = sort_hash.values.first
+        yield attribute, direction
+      end
+    end
+
+    def sort_param
+      @sort_param ||= begin
+        if query_hash[:sort].blank?
+          resource.default_sort
+        else
+          query_hash[:sort]
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/sideload.rb

@@ -0,0 +1,281 @@
+module Graphiti
+  class Sideload
+    HOOK_ACTIONS = [:save, :create, :update, :destroy, :disassociate]
+    TYPES = [:has_many, :belongs_to, :has_one, :many_to_many]
+
+    attr_reader :name,
+      :resource_class,
+      :parent_resource_class,
+      :foreign_key,
+      :primary_key,
+      :parent,
+      :group_name
+
+    class_attribute :scope_proc,
+      :assign_proc,
+      :assign_each_proc,
+      :params_proc,
+      :pre_load_proc
+
+    def initialize(name, opts)
+      @name                  = name
+      @parent_resource_class = opts[:parent_resource]
+      @resource_class        = opts[:resource]
+      @primary_key           = opts[:primary_key]
+      @foreign_key           = opts[:foreign_key]
+      @type                  = opts[:type]
+      @base_scope            = opts[:base_scope]
+      @readable              = opts[:readable]
+      @writable              = opts[:writable]
+      @as                    = opts[:as]
+
+      # polymorphic-specific
+      @group_name            = opts[:group_name]
+      @polymorphic_child     = opts[:polymorphic_child]
+      @parent                = opts[:parent]
+      if polymorphic_child?
+        parent.resource.polymorphic << resource_class
+      end
+    end
+
+    def self.scope(&blk)
+      self.scope_proc = blk
+    end
+
+    def self.assign(&blk)
+      self.assign_proc = blk
+    end
+
+    def self.assign_each(&blk)
+      self.assign_each_proc = blk
+    end
+
+    def self.params(&blk)
+      self.params_proc = blk
+    end
+
+    def self.pre_load(&blk)
+      self.pre_load_proc = blk
+    end
+
+    def readable?
+      !!@readable
+    end
+
+    def writable?
+      !!@writable
+    end
+
+    def polymorphic_parent?
+      resource.polymorphic?
+    end
+
+    def polymorphic_child?
+      !!@polymorphic_child
+    end
+
+    def primary_key
+      @primary_key ||= :id
+    end
+
+    def foreign_key
+      @foreign_key ||= infer_foreign_key
+    end
+
+    def association_name
+      @as || name
+    end
+
+    def resource_class
+      @resource_class ||= infer_resource_class
+    end
+
+    def scope(parents)
+      raise "No #scope defined for sideload with name '#{name}'. Make sure to define this in your adapter, or pass a block that defines the scope."
+    end
+
+    def assign_each(parent, children)
+      raise 'Override #assign_each in subclass'
+    end
+
+    def type
+      @type || raise("Override #type in subclass. Should be one of #{TYPES.inspect}")
+    end
+
+    def load_params(parents, query)
+      raise 'Override #load_params in subclass'
+    end
+
+    def base_scope
+      if @base_scope
+        @base_scope.respond_to?(:call) ? @base_scope.call : @base_scope
+      else
+        resource.base_scope
+      end
+    end
+
+    def load(parents, query)
+      params = load_params(parents, query)
+      params_proc.call(params, parents, query) if params_proc
+      opts = load_options(parents, query)
+      proxy = resource.class._all(params, opts, base_scope)
+      pre_load_proc.call(proxy) if pre_load_proc
+      proxy.to_a
+    end
+
+    # Override in subclass
+    def infer_foreign_key
+      model = parent_resource_class.model
+      namespace = namespace_for(model)
+      model_name = model.name.gsub("#{namespace}::", '')
+      :"#{model_name.underscore}_id"
+    end
+
+    def resource
+      @resource ||= resource_class.new
+    end
+
+    def parent_resource
+      @parent_resource ||= parent_resource_class.new
+    end
+
+    def assign(parents, children)
+      associated = []
+      parents.each do |parent|
+        relevant_children = fire_assign_each(parent, children)
+        if relevant_children.is_a?(Array)
+          associated |= relevant_children
+          associate_all(parent, relevant_children)
+        else
+          associated << relevant_children
+          associate(parent, relevant_children)
+        end
+      end
+      (children - associated).each do |unassigned|
+        children.delete(unassigned)
+      end
+    end
+
+    def resolve(parents, query)
+      # legacy / custom / many-to-many
+      if self.class.scope_proc || type == :many_to_many
+        sideload_scope = fire_scope(parents)
+        sideload_scope = Scope.new sideload_scope,
+          resource,
+          query,
+          sideload_parent_length: parents.length,
+          default_paginate: false
+        sideload_scope.resolve do |sideload_results|
+          fire_assign(parents, sideload_results)
+        end
+      else
+        load(parents, query)
+      end
+    end
+
+    def self.after_save(only: [], except: [], &blk)
+      actions = HOOK_ACTIONS - except
+      actions = only & actions
+      actions = [:save] if only.empty? && except.empty?
+      actions.each do |a|
+        hooks[:"after_#{a}"] << blk
+      end
+    end
+
+    def self.hooks
+      @hooks ||= {}.tap do |h|
+        HOOK_ACTIONS.each do |a|
+          h[:"after_#{a}"] = []
+          h[:"before_#{a}"] = []
+        end
+      end
+    end
+
+    def fire_hooks!(parent, objects, method)
+      return unless self.class.hooks
+
+      all = self.class.hooks[:"after_#{method}"] + self.class.hooks[:after_save]
+      all.compact.each do |hook|
+        resource.instance_exec(parent, objects, &hook)
+      end
+    end
+
+    def associate_all(parent, children)
+      parent_resource.associate_all(parent, children, association_name, type)
+    end
+
+    def associate(parent, child)
+      parent_resource.associate(parent, child, association_name, type)
+    end
+
+    def disassociate(parent, child)
+      parent_resource.disassociate(parent, child, association_name, type)
+    end
+
+    def ids_for_parents(parents)
+      parent_ids = parents.map(&primary_key)
+      parent_ids.compact!
+      parent_ids.uniq!
+      parent_ids
+    end
+
+    private
+
+    def load_options(parents, query)
+      {}.tap do |opts|
+        opts[:default_paginate] = false
+        opts[:sideload_parent_length] = parents.length
+        opts[:after_resolve] = ->(results) {
+          fire_assign(parents, results)
+        }
+      end
+    end
+
+    def fire_assign_each(parent, children)
+      if self.class.assign_each_proc
+        instance_exec(parent, children, &self.class.assign_each_proc)
+      else
+        assign_each(parent, children)
+      end
+    end
+
+    def fire_assign(parents, children)
+      if self.class.assign_proc
+        instance_exec(parents, children, &self.class.assign_proc)
+      else
+        assign(parents, children)
+      end
+    end
+
+    def fire_scope(parents)
+      parent_ids = ids_for_parents(parents)
+      if self.class.scope_proc
+        instance_exec(parent_ids, parents, &self.class.scope_proc)
+      else
+        method = method(:scope)
+        if [2,-2].include?(method.arity)
+          scope(parent_ids, parents)
+        else
+          scope(parent_ids)
+        end
+      end
+    end
+
+    def namespace_for(klass)
+      namespace = klass.name
+      split = namespace.split('::')
+      split[0,split.length-1].join('::')
+    end
+
+    def infer_resource_class
+      namespace = namespace_for(parent_resource.class)
+      inferred_name = "#{name.to_s.singularize.classify}Resource"
+      klass = "#{namespace}::#{inferred_name}".safe_constantize
+      klass ||= inferred_name.safe_constantize
+      unless klass
+        raise Errors::ResourceNotFound.new(parent_resource, name)
+      end
+      klass
+    end
+  end
+end

data/lib/graphiti/sideload/belongs_to.rb

@@ -0,0 +1,34 @@
+class Graphiti::Sideload::BelongsTo < Graphiti::Sideload
+  def type
+    :belongs_to
+  end
+
+  def load_params(parents, query)
+    query.to_hash.tap do |hash|
+      hash[:filter] ||= {}
+      hash[:filter][primary_key] = ids_for_parents(parents)
+    end
+  end
+
+  def assign_each(parent, children)
+    children.find { |c| c.send(primary_key) == parent.send(foreign_key) }
+  end
+
+  def ids_for_parents(parents)
+    parent_ids = parents.map(&foreign_key)
+    parent_ids.compact!
+    parent_ids.uniq!
+    parent_ids
+  end
+
+  def infer_foreign_key
+    if polymorphic_child?
+      parent.foreign_key
+    else
+      model = resource.model
+      namespace = namespace_for(model)
+      model_name = model.name.gsub("#{namespace}::", '')
+      :"#{model_name.underscore}_id"
+    end
+  end
+end