graphiti 1.2.21 → 1.2.29

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36b58f545ff99d459f7739072dd54045a8eee7f06990f7cee8450c1311788feb
-  data.tar.gz: bab55c98392e96c793b51bac6423c63b171782f36fddd3ef57531e4d3f280f9b
+  metadata.gz: 4a1198667bd97f2aed53ee9652bf58e778c9423541e85c40122fcca1e504af6a
+  data.tar.gz: 58b4a16c2344147408b8f6bae93ba0f7268f45db8e1fdb0782f2eb452257f6af
 SHA512:
-  metadata.gz: dc9a8a3dce388ba6cec8100cbbd16c0c04e7aa0559acd2d3b028d00ce869537fce70c395e524c33351b4066142a48cecd3ee76bbf6c8d8b25e1fb38e997b0556
-  data.tar.gz: fbf3374a770546d24e62ebbc96091264f823ddeaaf99329eb0f51dfcfb918df999dcf6025aeb87868754671c079058e9a3e664db15c77cf6e00f1958a1b80ddd
+  metadata.gz: 4000d1e9f172c3cb1b973d8545dc02d6771951ed16efac8e21ce948de2a7ebb457115128d375dfda7f0d05bc334ab2851f6d69b0de8c23530bae8c47702d12f4
+  data.tar.gz: a10bfea53ddbd2af821d9467204fd4550a288fe6a5f57b02e63915e7d14230b00924ec20a0f3e350c1282bf9aeaf75a043ce5309ca83bf892c900f5add59f776

data/.travis.yml

@@ -19,7 +19,13 @@ env:
   - COMMAND="standardrb --no-fix --format progress"
   - COMMAND=rspec
   - COMMAND=rspec APPRAISAL_INITIALIZED=true
-matrix:
+jobs:
+  allow_failures:
+  - rvm: ruby-head
+  include:
+    - env: COMMAND=rspec
+      gemfile: Gemfile
+      rvm: ruby-head
   exclude:
     # Don't run the appraisal version of the specs for the base gemfile
     - env: COMMAND=rspec APPRAISAL_INITIALIZED=true

data/CHANGELOG.md

@@ -8,6 +8,9 @@ Features:
 - [157](https://github.com/graphiti-api/graphiti/pull/157) Using attribute option schema: false.
   This option is default true and is not effected by only and except options. (@zeisler)
 
+Fixes:
+- [282] Support model names including "Resource"
+
 ## 1.1.0
 
 Features:

data/Gemfile

@@ -3,8 +3,6 @@ source "https://rubygems.org"
 # Specify your gem's dependencies in graphiti.gemspec
 gemspec
 
-gem "standard", "0.4.7"
-
 group :test do
   gem "pry"
   gem "pry-byebug", platform: [:mri]

data/gemfiles/rails_4.gemfile

@@ -2,7 +2,7 @@
 
 source "https://rubygems.org"
 
-gem "rails", "~> 4.1"
+gem "rails", "~> 4.2"
 gem "rspec-rails"
 gem "sqlite3", "~> 1.3.6"
 gem "database_cleaner"

data/graphiti.gemspec

@@ -16,7 +16,7 @@ Gem::Specification.new do |spec|
   spec.bindir = "exe"
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
-  spec.required_ruby_version = "~> 2.3"
+  spec.required_ruby_version = [">= 2.3", "< 3.1"]
 
   spec.add_dependency "jsonapi-serializable", "~> 0.3.0"
   spec.add_dependency "jsonapi-renderer", "~> 0.2", ">= 0.2.2"
@@ -29,6 +29,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "kaminari", "~> 0.17"
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "standard", "0.4.7"
   spec.add_development_dependency "activemodel", ">= 4.1"
   spec.add_development_dependency "graphiti_spec_helpers", "1.0.beta.4"
 end

data/lib/graphiti/adapters/abstract.rb

@@ -1,6 +1,9 @@
 module Graphiti
   module Adapters
     class Abstract
+      require "graphiti/adapters/persistence/associations.rb"
+      include Graphiti::Adapters::Persistence::Associations
+
       attr_reader :resource
 
       def initialize(resource)
@@ -400,6 +403,13 @@ module Graphiti
         raise "you must override #destroy in an adapter subclass"
       end
 
+      def close
+      end
+
+      def persistence_attributes(persistance, attributes)
+        attributes
+      end
+
       def self.numerical_operators
         [:eq, :not_eq, :gt, :gte, :lt, :lte].freeze
       end

data/lib/graphiti/adapters/active_record.rb

@@ -1,7 +1,7 @@
 module Graphiti
   module Adapters
     class ActiveRecord < ::Graphiti::Adapters::Abstract
-      require "graphiti/adapters/active_record/inferrence"
+      require "graphiti/adapters/active_record/inference"
       require "graphiti/adapters/active_record/has_many_sideload"
       require "graphiti/adapters/active_record/belongs_to_sideload"
       require "graphiti/adapters/active_record/has_one_sideload"
@@ -191,7 +191,7 @@ module Graphiti
       # (see Adapters::Abstract#count)
       def count(scope, attr)
         if attr.to_sym == :total
-          scope.distinct.count
+          scope.distinct.count(:all)
         else
           scope.distinct.count(attr)
         end
@@ -297,6 +297,10 @@ module Graphiti
         model_instance
       end
 
+      def close
+        ActiveRecord::Base.clear_active_connections!
+      end
+
       private
 
       def column_for(scope, name)

data/lib/graphiti/adapters/active_record/belongs_to_sideload.rb

@@ -1,5 +1,5 @@
 class Graphiti::Adapters::ActiveRecord::BelongsToSideload < Graphiti::Sideload::BelongsTo
-  include Graphiti::Adapters::ActiveRecord::Inferrence
+  include Graphiti::Adapters::ActiveRecord::Inference
 
   def default_base_scope
     resource_class.model.all

data/lib/graphiti/adapters/active_record/has_many_sideload.rb

@@ -1,5 +1,5 @@
 class Graphiti::Adapters::ActiveRecord::HasManySideload < Graphiti::Sideload::HasMany
-  include Graphiti::Adapters::ActiveRecord::Inferrence
+  include Graphiti::Adapters::ActiveRecord::Inference
 
   def default_base_scope
     resource_class.model.all

data/lib/graphiti/adapters/active_record/has_one_sideload.rb

@@ -1,5 +1,5 @@
 class Graphiti::Adapters::ActiveRecord::HasOneSideload < Graphiti::Sideload::HasOne
-  include Graphiti::Adapters::ActiveRecord::Inferrence
+  include Graphiti::Adapters::ActiveRecord::Inference
 
   def default_base_scope
     resource_class.model.all

data/lib/graphiti/adapters/active_record/{inferrence.rb → inference.rb}

@@ -1,6 +1,6 @@
-module Graphiti::Adapters::ActiveRecord::Inferrence
+module Graphiti::Adapters::ActiveRecord::Inference
   # If going AR to AR, use AR introspection
-  # If going AR to PORO, fall back to normal inferrence
+  # If going AR to PORO, fall back to normal inference
   def infer_foreign_key
     parent_model = parent_resource_class.model
     reflection = parent_model.reflections[association_name.to_s]

data/lib/graphiti/adapters/active_record/many_to_many_sideload.rb

@@ -8,6 +8,18 @@ class Graphiti::Adapters::ActiveRecord::ManyToManySideload < Graphiti::Sideload:
     foreign_key.keys.first
   end
 
+  def inverse_filter
+    return @inverse_filter if @inverse_filter
+
+    inferred_name = infer_inverse_association
+
+    if inferred_name
+      "#{inferred_name.to_s.singularize}_id"
+    else
+      super
+    end
+  end
+
   def belongs_to_many_filter(scope, value)
     if polymorphic?
       clauses = value.group_by { |v| v["type"] }.map { |group|
@@ -36,8 +48,7 @@ class Graphiti::Adapters::ActiveRecord::ManyToManySideload < Graphiti::Sideload:
 
   def filter_for(scope, value, type = nil)
     scope
-      .preload(through_relationship_name)
-      .joins(through_relationship_name)
+      .includes(through_relationship_name)
       .where(belongs_to_many_clause(value, type))
   end
 
@@ -76,4 +87,11 @@ class Graphiti::Adapters::ActiveRecord::ManyToManySideload < Graphiti::Sideload:
     value = through_reflection.foreign_key.to_sym
     {key => value}
   end
+
+  def infer_inverse_association
+    through_class = through_reflection.klass
+
+    foreign_reflection = through_class.reflections[name.to_s.singularize]
+    foreign_reflection && foreign_reflection.options[:inverse_of]
+  end
 end

data/lib/graphiti/adapters/persistence/associations.rb

@@ -0,0 +1,72 @@
+module Graphiti
+  module Adapters
+    module Persistence
+      module Associations
+        def process_belongs_to(persistence, attributes)
+          parents = [].tap do |processed|
+            persistence.iterate(only: [:polymorphic_belongs_to, :belongs_to]) do |x|
+              begin
+                id = x.dig(:attributes, :id)
+                x[:object] = x[:resource]
+                  .persist_with_relationships(x[:meta], x[:attributes], x[:relationships])
+                processed << x
+              rescue Graphiti::Errors::RecordNotFound
+                path = "relationships/#{x.dig(:meta, :jsonapi_type)}"
+                raise Graphiti::Errors::RecordNotFound.new(x[:sideload].name, id, path)
+              end
+            end
+          end
+
+          update_foreign_key_for_parents(parents, attributes)
+          parents
+        end
+
+        def process_has_many(persistence, caller_model)
+          [].tap do |processed|
+            persistence.iterate(except: [:polymorphic_belongs_to, :belongs_to]) do |x|
+              update_foreign_key(caller_model, x[:attributes], x)
+
+              x[:object] = x[:resource]
+                .persist_with_relationships(x[:meta], x[:attributes], x[:relationships], caller_model, x[:foreign_key])
+
+              processed << x
+            end
+          end
+        end
+
+        def update_foreign_key_for_parents(parents, attributes)
+          parents.each do |x|
+            update_foreign_key(x[:object], attributes, x)
+          end
+        end
+
+        # The child's attributes should be modified to nil-out the
+        # foreign_key when the parent is being destroyed or disassociated
+        #
+        # This is not the case for HABTM, whose "foreign key" is a join table
+        def update_foreign_key(parent_object, attrs, x)
+          return if x[:sideload].type == :many_to_many
+
+          if [:destroy, :disassociate].include?(x[:meta][:method])
+            if x[:sideload].polymorphic_has_one? || x[:sideload].polymorphic_has_many?
+              attrs[:"#{x[:sideload].polymorphic_as}_type"] = nil
+            end
+            attrs[x[:foreign_key]] = nil
+            update_foreign_type(attrs, x, null: true) if x[:is_polymorphic]
+          else
+            if x[:sideload].polymorphic_has_one? || x[:sideload].polymorphic_has_many?
+              attrs[:"#{x[:sideload].polymorphic_as}_type"] = parent_object.class.name
+            end
+            attrs[x[:foreign_key]] = parent_object.send(x[:primary_key])
+            update_foreign_type(attrs, x) if x[:is_polymorphic]
+          end
+        end
+
+        def update_foreign_type(attrs, x, null: false)
+          grouping_field = x[:sideload].parent.grouper.field_name
+          attrs[grouping_field] = null ? nil : x[:sideload].group_name
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/delegates/pagination.rb

@@ -6,7 +6,7 @@ module Graphiti
       end
 
       def links?
-        @proxy.query.pagination_links?
+        @proxy.query.pagination_links? && @proxy.data.present?
       end
 
       def links
@@ -53,7 +53,7 @@ module Graphiti
       def item_count
         begin
           return @item_count if @item_count
-          @item_count = @proxy.resource.stat(:total, :count).call(@proxy.scope.unpaginated_object, :total)
+          @item_count = item_count_from_proxy || item_count_from_stats
           unless @item_count.is_a?(Numeric)
             raise TypeError, "#{@proxy.resource}.stat(:total, :count) returned an invalid value #{@item_count}"
           end
@@ -68,6 +68,15 @@ module Graphiti
         @item_count
       end
 
+      def item_count_from_proxy
+        @proxy.stats.dig(:total, :count)
+      end
+
+      def item_count_from_stats
+        stats = Stats::Payload.new(@proxy.resource, @proxy.query, @proxy.scope.unpaginated_object, @proxy.data)
+        stats.calculate_stat(:total, @proxy.resource.stat(:total, :count))
+      end
+
       def current_page
         @current_page ||= (page_param[:number] || 1).to_i
       end

data/lib/graphiti/errors.rb

@@ -366,6 +366,20 @@ module Graphiti
       end
     end
 
+    class UndefinedIDLookup < Base
+      def initialize(resource_class)
+        @resource_class = resource_class
+      end
+
+      def message
+        <<~MSG
+          Tried to resolve #{@resource_class} with an :id filter, but the filter was nil.
+          This can result in unscoping a query, which can cause incorrect values to be
+          returned which may or may not bypass standard access controls.
+        MSG
+      end
+    end
+
     class UnknownAttribute < AttributeError
       def message
         "#{super}, but could not find an attribute with that name."

data/lib/graphiti/hash_renderer.rb

@@ -45,10 +45,10 @@ module Graphiti
       {}.tap do |hash|
         hash[:data] = if serializers.is_a?(Array)
           serializers.map do |s|
-            s.to_hash(opts)
+            s.to_hash(**opts)
           end
         else
-          serializers.to_hash(opts)
+          serializers.to_hash(**opts)
         end
       end
     end

data/lib/graphiti/request_validator.rb

@@ -6,18 +6,18 @@ module Graphiti
       :deserialized_payload,
       to: :@validator
 
-    def initialize(root_resource, raw_params)
-      @validator = ValidatorFactory.create(root_resource, raw_params)
+    def initialize(root_resource, raw_params, action)
+      @validator = ValidatorFactory.create(root_resource, raw_params, action)
     end
 
     class ValidatorFactory
-      def self.create(root_resource, raw_params)
-        case raw_params["action"]
-        when "update" then
+      def self.create(root_resource, raw_params, action)
+        case action
+        when :update then
           RequestValidators::UpdateValidator
         else
           RequestValidators::Validator
-        end.new(root_resource, raw_params)
+        end.new(root_resource, raw_params, action)
       end
     end
   end

data/lib/graphiti/request_validators/validator.rb

@@ -3,10 +3,11 @@ module Graphiti
     class Validator
       attr_reader :errors
 
-      def initialize(root_resource, raw_params)
+      def initialize(root_resource, raw_params, action)
         @root_resource = root_resource
         @raw_params = raw_params
         @errors = Graphiti::Util::SimpleErrors.new(raw_params)
+        @action = action
       end
 
       def validate
@@ -50,7 +51,7 @@ module Graphiti
           relationships: relationships
         }
 
-        Graphiti::Util::RelationshipPayload.iterate(opts) do |x|
+        Graphiti::Util::RelationshipPayload.iterate(**opts) do |x|
           sideload_def = x[:sideload]
 
           unless sideload_def.writable?
@@ -68,6 +69,11 @@ module Graphiti
 
       def typecast_attributes(resource, attributes, payload_path)
         attributes.each_pair do |key, value|
+          # Only validate id if create action, otherwise it's only used for lookup
+          next if @action != :create &&
+            key == :id &&
+            resource.class.config[:attributes][:id][:writable] == false
+
           begin
             attributes[key] = resource.typecast(key, value, :writable)
           rescue Graphiti::Errors::UnknownAttribute

data/lib/graphiti/resource/configuration.rb

@@ -129,7 +129,7 @@ module Graphiti
         def get_attr(name, flag, opts = {})
           defaults = {request: false}
           opts = defaults.merge(opts)
-          new.get_attr(name, flag, opts)
+          new.get_attr(name, flag, **opts)
         end
 
         def abstract_class?
@@ -149,14 +149,14 @@ module Graphiti
 
         def infer_type
           if name.present?
-            name.demodulize.gsub("Resource", "").underscore.pluralize.to_sym
+            name.demodulize.sub(/.*\KResource/, "").underscore.pluralize.to_sym
           else
             :undefined_jsonapi_type
           end
         end
 
         def infer_model
-          name&.gsub("Resource", "")&.safe_constantize
+          name&.sub(/.*\KResource/, "")&.safe_constantize
         end
 
         # @api private
@@ -247,7 +247,7 @@ module Graphiti
 
       def get_attr!(name, flag, options = {})
         options[:raise_error] = true
-        get_attr(name, flag, options)
+        get_attr(name, flag, **options)
       end
 
       def get_attr(name, flag, request: false, raise_error: false)

data/lib/graphiti/resource/dsl.rb

@@ -5,6 +5,7 @@ module Graphiti
 
       class_methods do
         def filter(name, *args, &blk)
+          name = name.to_sym
           opts = args.extract_options!
           type_override = args[0]
 

data/lib/graphiti/resource/interface.rb

@@ -23,6 +23,9 @@ module Graphiti
 
         # @api private
         def _find(params = {}, base_scope = nil)
+          guard_nil_id!(params[:data])
+          guard_nil_id!(params)
+
           id = params[:data].try(:[], :id) || params.delete(:id)
           params[:filter] ||= {}
           params[:filter][:id] = id if id
@@ -52,6 +55,13 @@ module Graphiti
             end
           end
         end
+
+        def guard_nil_id!(params)
+          return unless params
+          if params.key?(:id) && params[:id].nil?
+            raise Errors::UndefinedIDLookup.new(self)
+          end
+        end
       end
     end
   end

data/lib/graphiti/resource_proxy.rb

@@ -93,7 +93,7 @@ module Graphiti
       original = Graphiti.context[:namespace]
       begin
         Graphiti.context[:namespace] = action
-        ::Graphiti::RequestValidator.new(@resource, @payload.params).validate!
+        ::Graphiti::RequestValidator.new(@resource, @payload.params, action).validate!
         validator = persist {
           @resource.persist_with_relationships \
             @payload.meta(action: action),
@@ -118,6 +118,7 @@ module Graphiti
     end
 
     def destroy
+      data
       transaction_response = @resource.transaction do
         metadata = {method: :destroy}
         model = @resource.destroy(@query.filters[:id], metadata)
@@ -135,6 +136,7 @@ module Graphiti
     end
 
     def update_attributes
+      data
       save(action: :update)
     end
 

data/lib/graphiti/runner.rb

@@ -9,8 +9,7 @@ module Graphiti
       @query = query
       @action = action
 
-      validator = RequestValidator.new(jsonapi_resource, params)
-
+      validator = RequestValidator.new(jsonapi_resource, params, action)
       validator.validate!
 
       @deserialized_payload = validator.deserialized_payload

data/lib/graphiti/scope.rb

@@ -45,9 +45,7 @@ module Graphiti
         resolve_sideload = -> {
           Graphiti.context = graphiti_context
           sideload.resolve(results, q, parent_resource)
-          if concurrent && defined?(ActiveRecord)
-            ActiveRecord::Base.clear_active_connections!
-          end
+          @resource.adapter.close if concurrent
         }
         if concurrent
           promises << Concurrent::Promise.execute(&resolve_sideload)

data/lib/graphiti/serializer.rb

@@ -22,8 +22,8 @@ module Graphiti
       end
     end
 
-    def as_jsonapi(*)
-      super.tap do |hash|
+    def as_jsonapi(kwargs = {})
+      super(**kwargs).tap do |hash|
         strip_relationships!(hash) if strip_relationships?
         add_links!(hash)
       end

data/lib/graphiti/sideload.rb

@@ -26,8 +26,8 @@ module Graphiti
       @foreign_key = opts[:foreign_key]
       @type = opts[:type]
       @base_scope = opts[:base_scope]
-      @readable = evaluate_flag(opts[:readable])
-      @writable = evaluate_flag(opts[:writable])
+      @readable = opts[:readable]
+      @writable = opts[:writable]
       @as = opts[:as]
       @link = opts[:link]
       @single = opts[:single]
@@ -426,6 +426,7 @@ module Graphiti
       Util::Class.namespace_for(klass)
     end
 
+    # TODO: call this at runtime to support procs
     def evaluate_flag(flag)
       return false if flag.blank?
 

data/lib/graphiti/stats/payload.rb

@@ -31,16 +31,19 @@ module Graphiti
             stats[name] = {}
 
             each_calculation(name, calculation) do |calc, function|
-              args = [@scope, name]
-              args << @resource.context if function.arity >= 3
-              args << @data if function.arity == 4
-
-              stats[name][calc] = function.call(*args)
+              stats[name][calc] = calculate_stat(name, function)
             end
           end
         end
       end
 
+      def calculate_stat(name, function)
+        args = [@scope, name]
+        args << @resource.context if function.arity >= 3
+        args << @data if function.arity == 4
+        function.call(*args)
+      end
+
       private
 
       def each_calculation(name, calculations)

data/lib/graphiti/util/attribute_check.rb

@@ -44,7 +44,7 @@ module Graphiti
           Graphiti::Errors::UnknownAttribute
 
         if raise_error?(opts[:exists])
-          raise error_class.new(resource, name, flag, opts)
+          raise error_class.new(resource, name, flag, **opts)
         else
           false
         end

data/lib/graphiti/util/persistence.rb

@@ -14,6 +14,7 @@ class Graphiti::Util::Persistence
     @relationships = relationships
     @caller_model = caller_model
     @foreign_key = foreign_key
+    @adapter = @resource.adapter
 
     # Find the correct child resource for a given jsonapi type
     if (meta_type = @meta[:type].try(:to_sym))
@@ -43,18 +44,16 @@ class Graphiti::Util::Persistence
   #
   # @return a model instance
   def run
-    parents = process_belongs_to(@relationships)
-    update_foreign_key_for_parents(parents)
+    attributes = @adapter.persistence_attributes(self, @attributes)
 
-    persisted = persist_object(@meta[:method], @attributes)
+    parents = @adapter.process_belongs_to(self, attributes)
+    persisted = persist_object(@meta[:method], attributes)
     @resource.decorate_record(persisted)
     assign_temp_id(persisted, @meta[:temp_id])
 
     associate_parents(persisted, parents)
 
-    children = process_has_many(@relationships, persisted) { |x|
-      update_foreign_key(persisted, x[:attributes], x)
-    }
+    children = @adapter.process_has_many(self, persisted)
 
     associate_children(persisted, children) unless @meta[:method] == :destroy
 
@@ -69,43 +68,21 @@ class Graphiti::Util::Persistence
     persisted
   end
 
-  private
-
-  def add_hook(prc, lifecycle_event)
-    ::Graphiti::Util::TransactionHooksRecorder.add(prc, lifecycle_event)
-  end
-
-  # The child's attributes should be modified to nil-out the
-  # foreign_key when the parent is being destroyed or disassociated
-  #
-  # This is not the case for HABTM, whose "foreign key" is a join table
-  def update_foreign_key(parent_object, attrs, x)
-    return if x[:sideload].type == :many_to_many
+  def iterate(only: [], except: [])
+    opts = {
+      resource: @resource,
+      relationships: @relationships
+    }.merge(only: only, except: except)
 
-    if [:destroy, :disassociate].include?(x[:meta][:method])
-      if x[:sideload].polymorphic_has_one? || x[:sideload].polymorphic_has_many?
-        attrs[:"#{x[:sideload].polymorphic_as}_type"] = nil
-      end
-      attrs[x[:foreign_key]] = nil
-      update_foreign_type(attrs, x, null: true) if x[:is_polymorphic]
-    else
-      if x[:sideload].polymorphic_has_one? || x[:sideload].polymorphic_has_many?
-        attrs[:"#{x[:sideload].polymorphic_as}_type"] = parent_object.class.name
-      end
-      attrs[x[:foreign_key]] = parent_object.send(x[:primary_key])
-      update_foreign_type(attrs, x) if x[:is_polymorphic]
+    Graphiti::Util::RelationshipPayload.iterate(**opts) do |x|
+      yield x
     end
   end
 
-  def update_foreign_type(attrs, x, null: false)
-    grouping_field = x[:sideload].parent.grouper.field_name
-    attrs[grouping_field] = null ? nil : x[:sideload].group_name
-  end
+  private
 
-  def update_foreign_key_for_parents(parents)
-    parents.each do |x|
-      update_foreign_key(x[:object], @attributes, x)
-    end
+  def add_hook(prc, lifecycle_event)
+    ::Graphiti::Util::TransactionHooksRecorder.add(prc, lifecycle_event)
   end
 
   def associate_parents(object, parents)
@@ -161,35 +138,6 @@ class Graphiti::Util::Persistence
     end
   end
 
-  def process_has_many(relationships, caller_model)
-    [].tap do |processed|
-      iterate(except: [:polymorphic_belongs_to, :belongs_to]) do |x|
-        yield x
-
-        x[:object] = x[:resource]
-          .persist_with_relationships(x[:meta], x[:attributes], x[:relationships], caller_model, x[:foreign_key])
-
-        processed << x
-      end
-    end
-  end
-
-  def process_belongs_to(relationships)
-    [].tap do |processed|
-      iterate(only: [:polymorphic_belongs_to, :belongs_to]) do |x|
-        begin
-          id = x.dig(:attributes, :id)
-          x[:object] = x[:resource]
-            .persist_with_relationships(x[:meta], x[:attributes], x[:relationships])
-          processed << x
-        rescue Graphiti::Errors::RecordNotFound
-          path = "relationships/#{x.dig(:meta, :jsonapi_type)}"
-          raise Graphiti::Errors::RecordNotFound.new(x[:sideload].name, id, path)
-        end
-      end
-    end
-  end
-
   def post_process(caller_model, processed)
     groups = processed.group_by { |x| x[:meta][:method] }
     groups.each_pair do |method, group|
@@ -205,17 +153,6 @@ class Graphiti::Util::Persistence
     object.instance_variable_set(:@_jsonapi_temp_id, temp_id)
   end
 
-  def iterate(only: [], except: [])
-    opts = {
-      resource: @resource,
-      relationships: @relationships
-    }.merge(only: only, except: except)
-
-    Graphiti::Util::RelationshipPayload.iterate(opts) do |x|
-      yield x
-    end
-  end
-
   def metadata
     {
       method: @meta[:method],

data/lib/graphiti/util/serializer_attributes.rb

@@ -55,13 +55,16 @@ module Graphiti
       def guard
         method_name = @attr[:readable]
         instance = @resource.new
+        attribute = @name.to_s
 
         -> {
           method = instance.method(method_name)
           if method.arity.zero?
             instance.instance_eval(&method_name)
-          else
+          elsif method.arity == 1
             instance.instance_exec(@object, &method)
+          else
+            instance.instance_exec(@object, attribute, &method)
           end
         }
       end

data/lib/graphiti/version.rb

@@ -1,3 +1,3 @@
 module Graphiti
-  VERSION = "1.2.21"
+  VERSION = "1.2.29"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphiti
 version: !ruby/object:Gem::Version
-  version: 1.2.21
+  version: 1.2.29
 platform: ruby
 authors:
 - Lee Richmond
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-07-26 00:00:00.000000000 Z
+date: 2020-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jsonapi-serializable
@@ -162,6 +162,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.7
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
@@ -190,7 +204,7 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 1.0.beta.4
-description: 
+description:
 email:
 - richmolj@gmail.com
 executables:
@@ -248,10 +262,11 @@ files:
 - lib/graphiti/adapters/active_record/belongs_to_sideload.rb
 - lib/graphiti/adapters/active_record/has_many_sideload.rb
 - lib/graphiti/adapters/active_record/has_one_sideload.rb
-- lib/graphiti/adapters/active_record/inferrence.rb
+- lib/graphiti/adapters/active_record/inference.rb
 - lib/graphiti/adapters/active_record/many_to_many_sideload.rb
 - lib/graphiti/adapters/graphiti_api.rb
 - lib/graphiti/adapters/null.rb
+- lib/graphiti/adapters/persistence/associations.rb
 - lib/graphiti/cli.rb
 - lib/graphiti/configuration.rb
 - lib/graphiti/context.rb
@@ -327,15 +342,18 @@ homepage: https://github.com/graphiti-api/graphiti
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - "~>"
+  - - ">="
     - !ruby/object:Gem::Version
       version: '2.3'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -343,7 +361,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.0.6
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Easily build jsonapi.org-compatible APIs
 test_files: []