jsonapi_compliable 0.11.34 → 1.0.alpha.2

data/lib/jsonapi_compliable/scoping/filter.rb

@@ -28,9 +28,12 @@ module JsonapiCompliable
     # aliases. If valid, call either the default or custom filtering logic.
     # @return the scope we are chaining/modifying
     def apply
-      raise JsonapiCompliable::Errors::RequiredFilter.new(missing_required_filters) unless required_filters_provided?
-      each_filter do |filter, value|
-        @scope = filter_scope(filter, value)
+      if missing_required_filters.any?
+        raise Errors::RequiredFilter.new(resource, missing_required_filters)
+      end
+
+      each_filter do |filter, operator, value|
+        @scope = filter_scope(filter, operator, value)
       end
 
       @scope
@@ -38,74 +41,52 @@ module JsonapiCompliable
 
     private
 
-    # If there's custom logic, run it, otherwise run the default logic
-    # specified in the adapter.
-    def filter_scope(filter, value)
-      if custom_scope = filter.values.first[:filter]
+    def filter_scope(filter, operator, value)
+      operator = operator.to_s.gsub('!', 'not_').to_sym
+
+      if custom_scope = filter.values.first[operator]
         custom_scope.call(@scope, value, resource.context)
       else
-        resource.adapter.filter(@scope, filter.keys.first, value)
+        filter_via_adapter(filter, operator, value)
       end
     end
 
-    def each_filter
-      filter_param.each_pair do |param_name, param_value|
-        filter = find_filter!(param_name.to_sym)
-        value  = param_value
-        value  = parse_string_arrays(value)
-        value  = normalize_string_values(value)
-        yield filter, value
-      end
-    end
+    def filter_via_adapter(filter, operator, value)
+      type_name = Types.name_for(filter.values.first[:type])
+      method    = :"filter_#{type_name}_#{operator}"
+      attribute = filter.keys.first
 
-    # foo,bar,baz becomes ["foo", "bar", "baz"]
-    # {{foo}} becomes ["foo"]
-    # {{foo,bar}},baz becomes ["foo,bar", "baz"]
-    #
-    # JSON of
-    # {{{ "id": 1 }}} becomes { 'id' => 1 }
-    def parse_string_arrays(value)
-      if value.is_a?(String)# && value[0..2] != '{{{'
-        # Escaped JSON
-        if value[0..2] == '{{{'
-          value = value.sub('{{', '').sub('}}', '')
-          value = JSON.parse(value)
-        else
-          # Find the quoted strings
-          quotes = value.scan(/{{.*?}}/)
-          # remove them from the rest
-          quotes.each { |q| value.gsub!(q, '') }
-          # remove the quote characters from the quoted strings
-          quotes.each { |q| q.gsub!('{{', '').gsub!('}}', '') }
-          # merge everything back together into an array
-          value = Array(value.split(',')) + quotes
-          # remove any blanks that are left
-          value.reject! { |v| v.length.zero? }
-          value = value[0] if value.length == 1
-        end
+      if resource.adapter.respond_to?(method)
+        resource.adapter.send(method, @scope, attribute, value)
+      else
+        raise Errors::AdapterNotImplemented.new \
+          resource.adapter, attribute, method
       end
-      value
     end
 
-    # Convert a string of "true" to true, etc
-    #
-    # NB - avoid Array(value) here since we might want to
-    # return a single element instead of array
-    def normalize_string_values(value)
-      if value.is_a?(Array)
-        value.map { |v| normalize_string_value(v) }
-      else
-        normalize_string_value(value)
+    def each_filter
+      filter_param.each_pair do |param_name, param_value|
+        filter = find_filter!(param_name)
+        param_value = { eq: param_value } unless param_value.is_a?(Hash)
+        value = param_value.values.first
+        operator = param_value.keys.first
+        value = param_value.values.first unless filter.values[0][:type] == :hash
+        value = value.split(',') if value.is_a?(String) && value.include?(',')
+        value = coerce_types(param_name.to_sym, value)
+        yield filter, operator, value
       end
     end
 
-    def normalize_string_value(value)
-      case value
-      when 'true' then true
-      when 'false' then false
-      when 'nil', 'null' then nil
+    def coerce_types(name, value)
+      type_name = @resource.all_attributes[name][:type]
+      is_array = type_name.to_s.starts_with?('array_of') ||
+        Types[type_name][:canonical_name] == :array
+
+      if is_array
+        @resource.typecast(name, value, :filterable)
       else
-        value
+        value = value.nil? || value.is_a?(Hash) ? [value] : Array(value)
+        value.map { |v| @resource.typecast(name, v, :filterable) }
       end
     end
   end

data/lib/jsonapi_compliable/scoping/filterable.rb

@@ -4,34 +4,29 @@ module JsonapiCompliable
     # @api private
     def find_filter(name)
       find_filter!(name)
-    rescue JsonapiCompliable::Errors::BadFilter
+    rescue JsonapiCompliable::Errors::AttributeError
       nil
     end
 
     # @api private
     def find_filter!(name)
-      filter_name, filter_value = \
-        resource.filters.find { |_name, opts| opts[:aliases].include?(name.to_sym) }
-      raise JsonapiCompliable::Errors::BadFilter unless filter_name
-      if guard = filter_value[:if]
-        raise JsonapiCompliable::Errors::BadFilter if resource.context.send(guard) == false
-      end
-      { filter_name => filter_value }
+      resource.class.get_attr!(name, :filterable, request: true)
+      { name => resource.filters[name] }
     end
 
     # @api private
     def filter_param
-      query_hash[:filter]
+      query_hash[:filter] || {}
     end
 
     def missing_required_filters
-      required_filters.keys - filter_param.keys
+      required_attributes - filter_param.keys
     end
 
-    def required_filters
-      resource.filters.select do |_name, opts|
-        opts[:required].respond_to?(:call) ? opts[:required].call(resource.context) : opts[:required]
-      end
+    def required_attributes
+      resource.attributes.map do |k, v|
+        k if v[:filterable] == :required
+      end.compact
     end
 
     def required_filters_provided?

data/lib/jsonapi_compliable/scoping/paginate.rb

@@ -31,6 +31,8 @@ module JsonapiCompliable
       if size > MAX_PAGE_SIZE
         raise JsonapiCompliable::Errors::UnsupportedPageSize
           .new(size, MAX_PAGE_SIZE)
+      elsif requested? && @opts[:sideload_parent_length].to_i > 1
+        raise JsonapiCompliable::Errors::UnsupportedPagination
       else
         super
       end
@@ -42,8 +44,8 @@ module JsonapiCompliable
     #
     # @return [Boolean] should we apply this logic?
     def apply?
-      if @opts[:default] == false
-        not [page_param[:size], page_param[:number]].all?(&:nil?)
+      if @opts[:default_paginate] == false
+        requested?
       else
         true
       end
@@ -66,12 +68,16 @@ module JsonapiCompliable
 
     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] || resource.default_page_number).to_i
+      (page_param[:number] || 1).to_i
     end
 
     def size

data/lib/jsonapi_compliable/scoping/sort.rb

@@ -15,14 +15,18 @@ module JsonapiCompliable
   class Scoping::Sort < Scoping::Base
     # @return [Proc, Nil] The custom proc specified by Resource DSL
     def custom_scope
-      resource.sorting
+      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|
-        @scope = resource.adapter.order(@scope, attribute, direction)
+        if sort = resource.sorts[attribute]
+          @scope = sort.call(@scope, direction)
+        else
+          @scope = resource.adapter.order(@scope, attribute, direction)
+        end
       end
       @scope
     end
@@ -41,12 +45,20 @@ module JsonapiCompliable
 
     def each_sort
       sort_param.each do |sort_hash|
-        yield sort_hash.keys.first, sort_hash.values.first
+        attribute = sort_hash.keys.first
+        direction = sort_hash.values.first
+        yield attribute, direction
       end
     end
 
     def sort_param
-      @sort_param ||= query_hash[:sort].empty? ? resource.default_sort : query_hash[:sort]
+      @sort_param ||= begin
+        if query_hash[:sort].blank?
+          resource.default_sort
+        else
+          query_hash[:sort]
+        end
+      end
     end
   end
 end

data/lib/jsonapi_compliable/sideload.rb

@@ -1,220 +1,179 @@
 module JsonapiCompliable
-  # @attr_reader [Symbol] name The name of the sideload
-  # @attr_reader [Class] resource_class The corresponding Resource class
-  # @attr_reader [Boolean] polymorphic Is this a polymorphic sideload?
-  # @attr_reader [Hash] polymorphic_groups The subgroups, when polymorphic
-  # @attr_reader [Hash] sideloads The associated sibling sideloads
-  # @attr_reader [Proc] scope_proc The configured 'scope' block
-  # @attr_reader [Proc] assign_proc The configured 'assign' block
-  # @attr_reader [Symbol] grouping_field The configured 'group_by' symbol
-  # @attr_reader [Symbol] foreign_key The attribute used to match objects - need not be a true database foreign key.
-  # @attr_reader [Symbol] primary_key The attribute used to match objects - need not be a true database primary key.
-  # @attr_reader [Symbol] type One of :has_many, :belongs_to, etc
   class Sideload
+    HOOK_ACTIONS = [:save, :create, :update, :destroy, :disassociate]
+    TYPES = [:has_many, :belongs_to, :has_one, :many_to_many]
+
     attr_reader :name,
       :resource_class,
-      :polymorphic,
-      :polymorphic_groups,
-      :parent,
-      :sideloads,
-      :scope_proc,
-      :assign_proc,
-      :grouping_field,
+      :parent_resource_class,
       :foreign_key,
       :primary_key,
-      :type
-
-    # NB - the adapter's +#sideloading_module+ is mixed in on instantiation
-    #
-    # An anonymous Resource will be assigned when none provided.
-    #
-    # @see Adapters::Abstract#sideloading_module
-    def initialize(name, type: nil, resource: nil, polymorphic: false, primary_key: :id, foreign_key: nil, parent: nil)
-      @name               = name
-      @resource_class     = (resource || Class.new(Resource))
-      @sideloads          = {}
-      @polymorphic        = !!polymorphic
-      @polymorphic_groups = {} if polymorphic?
-      @parent             = parent
-      @primary_key        = primary_key
-      @foreign_key        = foreign_key
-      @type               = type
-
-      extend @resource_class.config[:adapter].sideloading_module
-    end
-
-    # @see #resource_class
-    # @return [Resource] an instance of +#resource_class+
+      :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
 
-    # Is this sideload polymorphic?
-    #
-    # Polymorphic sideloads group the parent objects in some fashion,
-    # so different 'types' can be resolved differently. Let's say an
-    # +Office+ has a polymorphic +Organization+, which can be either a
-    # +Business+ or +Government+:
-    #
-    #   allow_sideload :organization, :polymorphic: true do
-    #     group_by :organization_type
-    #
-    #     allow_sideload 'Business', resource: BusinessResource do
-    #       # ... code ...
-    #     end
-    #
-    #     allow_sideload 'Governemnt', resource: GovernmentResource do
-    #       # ... code ...
-    #     end
-    #   end
-    #
-    # You probably want to extract this code into an Adapter. For instance,
-    # with ActiveRecord:
-    #
-    #   polymorphic_belongs_to :organization,
-    #     group_by: :organization_type,
-    #     groups: {
-    #       'Business' => {
-    #         scope: -> { Business.all },
-    #         resource: BusinessResource,
-    #         foreign_key: :organization_id
-    #       },
-    #       'Government' => {
-    #         scope: -> { Government.all },
-    #         resource: GovernmentResource,
-    #         foreign_key: :organization_id
-    #       }
-    #     }
-    #
-    # @see Adapters::ActiveRecordSideloading#polymorphic_belongs_to
-    # @return [Boolean] is this sideload polymorphic?
-    def polymorphic?
-      @polymorphic == true
-    end
-
-    # Build a scope that will be used to fetch the related records
-    # This scope will be further chained with filtering/sorting/etc
-    #
-    # You probably want to wrap this logic in an Adapter, instead of
-    # specifying in your resource directly.
-    #
-    # @example Default ActiveRecord
-    #   class PostResource < ApplicationResource
-    #     # ... code ...
-    #     allow_sideload :comments, resource: CommentResource do
-    #       scope do |posts|
-    #         Comment.where(post_id: posts.map(&:id))
-    #       end
-    #       # ... code ...
-    #     end
-    #   end
-    #
-    # @example Custom Scope
-    #   # In this example, our base scope is a Hash
-    #   scope do |posts|
-    #     { post_ids: posts.map(&:id) }
-    #   end
-    #
-    # @example ActiveRecord via Adapter
-    #   class PostResource < ApplicationResource
-    #     # ... code ...
-    #     has_many :comments,
-    #       scope: -> { Comment.all },
-    #       resource: CommentResource,
-    #       foreign_key: :post_id
-    #   end
-    #
-    # @see Adapters::Abstract
-    # @see Adapters::ActiveRecordSideloading#has_many
-    # @see #allow_sideload
-    # @yieldparam parents - The resolved parent records
-    def scope(&blk)
-      @scope_proc = blk
-    end
-
-    # The proc used to assign the resolved parents and children.
-    #
-    # You probably want to wrap this logic in an Adapter, instead of
-    # specifying in your resource directly.
-    #
-    # @example Default ActiveRecord
-    #   class PostResource < ApplicationResource
-    #     # ... code ...
-    #     allow_sideload :comments, resource: CommentResource do
-    #       # ... code ...
-    #       assign do |posts, comments|
-    #         posts.each do |post|
-    #           relevant_comments = comments.select { |c| c.post_id == post.id }
-    #           post.comments = relevant_comments
-    #         end
-    #       end
-    #     end
-    #   end
-    #
-    # @example ActiveRecord via Adapter
-    #   class PostResource < ApplicationResource
-    #     # ... code ...
-    #     has_many :comments,
-    #       scope: -> { Comment.all },
-    #       resource: CommentResource,
-    #       foreign_key: :post_id
-    #   end
-    #
-    # @see Adapters::Abstract
-    # @see Adapters::ActiveRecordSideloading#has_many
-    # @see #allow_sideload
-    # @yieldparam parents - The resolved parent records
-    # @yieldparam children - The resolved child records
-    def assign(&blk)
-      @assign_proc = blk
-    end
-
-    # Configure how to associate parent and child records.
-    # Delegates to #resource
-    #
-    # @see #name
-    # @see #type
-    # @api private
-    def associate(parent, child)
-      association_name = @parent ? @parent.name : name
-      resource.associate(parent, child, association_name, type)
+    def parent_resource
+      @parent_resource ||= parent_resource_class.new
     end
 
-    # Configure how to disassociate parent and child records.
-    # Delegates to #resource
-    #
-    # @see #name
-    # @see #type
-    # @api private
-    def disassociate(parent, child)
-      association_name = @parent ? @parent.name : name
-      resource.disassociate(parent, child, association_name, type)
+    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
 
-    HOOK_ACTIONS = [:save, :create, :update, :destroy, :disassociate]
+    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
 
-    # Configure post-processing hooks
-    #
-    # In particular, helpful for bulk operations. "after_save" will fire
-    # for any persistence method - +:create+, +:update+, +:destroy+, +:disassociate+.
-    # Use "only" and "except" keyword arguments to fire only for a
-    # specific persistence method.
-    #
-    # @example Bulk Notify Users on Invite
-    #   class ProjectResource < ApplicationResource
-    #     # ... code ...
-    #     allow_sideload :users, resource: UserResource do
-    #       # scope {}
-    #       # assign {}
-    #       after_save only: [:create] do |project, users|
-    #         UserMailer.invite(project, users).deliver_later
-    #       end
-    #     end
-    #   end
-    #
-    # @see #hooks
-    # @see Util::Persistence
-    def after_save(only: [], except: [], &blk)
+    def self.after_save(only: [], except: [], &blk)
       actions = HOOK_ACTIONS - except
       actions = only & actions
       actions = [:save] if only.empty? && except.empty?
@@ -223,10 +182,7 @@ module JsonapiCompliable
       end
     end
 
-    # Get the hooks the user has configured
-    # @see #after_save
-    # @return hash of hooks, ie +{ after_create: #<Proc>}+
-    def hooks
+    def self.hooks
       @hooks ||= {}.tap do |h|
         HOOK_ACTIONS.each do |a|
           h[:"after_#{a}"] = []
@@ -235,173 +191,91 @@ module JsonapiCompliable
       end
     end
 
-    # Define an attribute that groups the parent records. For instance, with
-    # an ActiveRecord polymorphic belongs_to there will be a +parent_id+
-    # and +parent_type+. We would want to group on +parent_type+:
-    #
-    #  allow_sideload :organization, polymorphic: true do
-    #    # group parent_type, parent here is 'organization'
-    #    group_by :organization_type
-    #  end
-    #
-    # @see #polymorphic?
-    def group_by(grouping_field)
-      @grouping_field = grouping_field
-    end
-
-    # Resolve the sideload.
-    #
-    # * Uses the 'scope' proc to build a 'base scope'
-    # * Chains additional criteria onto that 'base scope'
-    # * Resolves that scope (see Scope#resolve)
-    # * Assigns the resulting child objects to their corresponding parents
-    #
-    # @see Scope#resolve
-    # @param [Object] parents The resolved parent models
-    # @param [Query] query The Query instance
-    # @param [Symbol] namespace The current namespace (see Resource#with_context)
-    # @see Query
-    # @see Resource#with_context
-    # @return [void]
-    # @api private
-    def resolve(parents, query, namespace)
-      if polymorphic?
-        resolve_polymorphic(parents, query)
-      else
-        resolve_basic(parents, query, namespace)
-      end
-    end
+    def fire_hooks!(parent, objects, method)
+      return unless self.class.hooks
 
-    # Configure a relationship between Resource objects
-    #
-    # You probably want to extract this logic into an adapter
-    # rather than using directly
-    #
-    # @example Default ActiveRecord
-    #   # What happens 'under the hood'
-    #   class CommentResource < ApplicationResource
-    #     # ... code ...
-    #     allow_sideload :post, resource: PostResource do
-    #       scope do |comments|
-    #         Post.where(id: comments.map(&:post_id))
-    #       end
-    #
-    #       assign do |comments, posts|
-    #         comments.each do |comment|
-    #           relevant_post = posts.find { |p| p.id == comment.post_id }
-    #           comment.post = relevant_post
-    #         end
-    #       end
-    #     end
-    #   end
-    #
-    #   # Rather than writing that code directly, go through the adapter:
-    #   class CommentResource < ApplicationResource
-    #     # ... code ...
-    #     use_adapter JsonapiCompliable::Adapters::ActiveRecord
-    #
-    #     belongs_to :post,
-    #       scope: -> { Post.all },
-    #       resource: PostResource,
-    #       foreign_key: :post_id
-    #   end
-    #
-    # @see Adapters::ActiveRecordSideloading#belongs_to
-    # @see #assign
-    # @see #scope
-    # @return void
-    def allow_sideload(name, opts = {}, &blk)
-      sideload = Sideload.new(name, opts)
-      sideload.instance_eval(&blk) if blk
-
-      if polymorphic?
-        @polymorphic_groups[name] = sideload
-      else
-        @sideloads[name] = sideload
+      all = self.class.hooks[:"after_#{method}"] + self.class.hooks[:after_save]
+      all.compact.each do |hook|
+        resource.instance_exec(parent, objects, &hook)
       end
     end
 
-    # Fetch a Sideload object by its name
-    # @param [Symbol] name The name of the corresponding sideload
-    # @see +allow_sideload
-    # @return the corresponding Sideload object
-    def sideload(name)
-      @sideloads[name]
+    def associate_all(parent, children)
+      parent_resource.associate_all(parent, children, association_name, type)
     end
 
-    # @api private
-    def all_sideloads
-      {}.tap do |all|
-        if polymorphic?
-          polymorphic_groups.each_pair do |type, sl|
-            all.merge!(sl.resource.sideloading.all_sideloads)
-          end
-        else
-          all.merge!(@sideloads.merge(resource.sideloading.sideloads))
-        end
-      end
+    def associate(parent, child)
+      parent_resource.associate(parent, child, association_name, type)
     end
 
-    def association_names(memo = [])
-      all_sideloads.each_pair do |name, sl|
-        unless memo.include?(sl.name)
-          memo << sl.name
-          memo |= sl.association_names(memo)
-        end
-      end
+    def disassociate(parent, child)
+      parent_resource.disassociate(parent, child, association_name, type)
+    end
 
-      memo
+    def ids_for_parents(parents)
+      parent_ids = parents.map(&primary_key)
+      parent_ids.compact!
+      parent_ids.uniq!
+      parent_ids
     end
 
-    # @api private
-    def polymorphic_child_for_type(type)
-      polymorphic_groups.values.find do |v|
-        v.resource_class.config[:type] == type.to_sym
+    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_hooks!(parent, objects, method)
-      return unless self.hooks
-
-      hooks = self.hooks[:"after_#{method}"] + self.hooks[:after_save]
-      hooks.compact.each do |hook|
-        resource.instance_exec(parent, objects, &hook)
+    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
 
-    private
+    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 polymorphic_grouper(grouping_field)
-      lambda do |record|
-        if record.is_a?(Hash)
-          if record.keys[0].is_a?(Symbol)
-            record[grouping_field]
-          else
-            record[grouping_field.to_s]
-          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
-          record.send(grouping_field)
+          scope(parent_ids)
         end
       end
     end
 
-    def resolve_polymorphic(parents, query)
-      grouper = polymorphic_grouper(@grouping_field)
-
-      parents.group_by(&grouper).each_pair do |group_type, group_members|
-        sideload_for_group = @polymorphic_groups[group_type]
-        if sideload_for_group
-          sideload_for_group.resolve(group_members, query, name)
-        end
-      end
+    def namespace_for(klass)
+      namespace = klass.name
+      split = namespace.split('::')
+      split[0,split.length-1].join('::')
     end
 
-    def resolve_basic(parents, query, namespace)
-      sideload_scope   = scope_proc.call(parents)
-      sideload_scope   = Scope.new(sideload_scope, resource_class.new, query, default_paginate: false, namespace: namespace)
-      sideload_scope.resolve do |sideload_results|
-        assign_proc.call(parents, sideload_results)
+    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