graphiti 1.13.4 → 2.0.0.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f23c59b6750dc9a8dcaefaba6d6250a9deac2676c33b01930b0c715767b85a1
-  data.tar.gz: 2252b0e870042723a30af9844d6006d8587f14228d82bc3eafd36c4b72b2fc8c
+  metadata.gz: a741f7953d1f54e730d2e801715f3b1d718044a4e0bd59cfd8bb3b364373e715
+  data.tar.gz: 99391699d407dfb92178cf851cce313d691ea930eb0ada81abe764b7a8310087
 SHA512:
-  metadata.gz: '0579733a14742e30623cb686c0ba0c925f34458501ee6a7b322da2a6aa0fe7a85a4ccc422bf969858ed5eae306e65f3c2fb4e554995db51b7437910bd46237b6'
-  data.tar.gz: aa3fcd0b1e671594e23bb006d126e55366633038b48c53332940f1ba5cfbf4782995cd4556867ad707bb9b13440d045208cc51b66d24b2bc070019d9eb9e108b
+  metadata.gz: 77d02ef7c1a525c286d56677ef103f56c7ea80873f565c6db72d2208d887fac967c8f9cddc6a06f940c4a62c6d7faf58390f5331f18fd2a562aa855fff002afd
+  data.tar.gz: e4e83880da4609da20727c8e8bf7b21cddc6e7436d571218da2f874e682dfdbe03c6960799e12614716b936881a8af95ee0459d6458afcaf5f3818dae198543e

data/.github/workflows/ci.yml

@@ -2,7 +2,7 @@ name: CI
 
 on:
   push:
-    branches: [main]
+    branches: [main, beta]
   pull_request: {}
   workflow_dispatch: {}
 
@@ -29,7 +29,6 @@ jobs:
       fail-fast: false
       matrix:
         ruby:
-          - "2.7"
           - "3.0"
           - "3.1"
           - "3.2"
@@ -37,10 +36,8 @@ jobs:
           - "3.4"
         gemfile:
           - Gemfile
-          - gemfiles/rails_5_2.gemfile
           - gemfiles/rails_6.gemfile
           - gemfiles/rails_7.gemfile
-          - gemfiles/rails_5_2_graphiti_rails.gemfile
           - gemfiles/rails_6_graphiti_rails.gemfile
           - gemfiles/rails_7_graphiti_rails.gemfile
           - gemfiles/rails_7_1_graphiti_rails.gemfile
@@ -70,14 +67,10 @@ jobs:
           # Skip some extra variants
           - gemfile: Gemfile
             appraisal: true
-          - gemfile: gemfiles/rails_5_2.gemfile
-            appraisal: false
           - gemfile: gemfiles/rails_6.gemfile
             appraisal: false
           - gemfile: gemfiles/rails_7.gemfile
             appraisal: false
-          - gemfile: gemfiles/rails_5_2_graphiti_rails.gemfile
-            appraisal: false
           - gemfile: gemfiles/rails_6_graphiti_rails.gemfile
             appraisal: false
           - gemfile: gemfiles/rails_7_graphiti_rails.gemfile
@@ -92,30 +85,22 @@ jobs:
             appraisal: false
 
           # Rails 8.1 needs ruby 3.2 +
-          - gemfile: gemfiles/rails_8_1_graphiti_rails.gemfile
-            ruby: 2.7
           - gemfile: gemfiles/rails_8_1_graphiti_rails.gemfile
             ruby: 3.0
           - gemfile: gemfiles/rails_8_1_graphiti_rails.gemfile
             ruby: 3.1
 
           # Rails 8 needs ruby 3.2 +
-          - gemfile: gemfiles/rails_8_0_graphiti_rails.gemfile
-            ruby: 2.7
           - gemfile: gemfiles/rails_8_0_graphiti_rails.gemfile
             ruby: 3.0
           - gemfile: gemfiles/rails_8_0_graphiti_rails.gemfile
             ruby: 3.1
 
           # Rails 7.2 needs ruby 3.1 +
-          - gemfile: gemfiles/rails_7_2_graphiti_rails.gemfile
-            ruby: 2.7
           - gemfile: gemfiles/rails_7_2_graphiti_rails.gemfile
             ruby: 3.0
 
           # Rails 7.1 needs ruby 3.0 +
-          - gemfile: gemfiles/rails_7_1_graphiti_rails.gemfile
-            ruby: 2.7
           - gemfile: gemfiles/rails_7_1_graphiti_rails.gemfile
             ruby: 3.0
 
@@ -133,27 +118,6 @@ jobs:
           - gemfile: gemfiles/rails_6_graphiti_rails.gemfile
             ruby: 3.4
 
-          # Rails 5 can't run on Ruby 3
-          - gemfile: gemfiles/rails_5_2.gemfile
-            ruby: 3.0
-          - gemfile: gemfiles/rails_5_2_graphiti_rails.gemfile
-            ruby: 3.0
-          - gemfile: gemfiles/rails_5_2.gemfile
-            ruby: 3.1
-          - gemfile: gemfiles/rails_5_2_graphiti_rails.gemfile
-            ruby: 3.1
-          - gemfile: gemfiles/rails_5_2.gemfile
-            ruby: 3.2
-          - gemfile: gemfiles/rails_5_2_graphiti_rails.gemfile
-            ruby: 3.2
-          - gemfile: gemfiles/rails_5_2.gemfile
-            ruby: 3.3
-          - gemfile: gemfiles/rails_5_2_graphiti_rails.gemfile
-            ruby: 3.3
-          - gemfile: gemfiles/rails_5_2.gemfile
-            ruby: 3.4
-          - gemfile: gemfiles/rails_5_2_graphiti_rails.gemfile
-            ruby: 3.4
     continue-on-error: ${{ matrix.ruby == 'ruby-head' }}
     env: # $BUNDLE_GEMFILE must be set at the job level, so it is set for all steps
       BUNDLE_GEMFILE: ${{ github.workspace }}/${{ matrix.gemfile }}
@@ -171,6 +135,8 @@ jobs:
   publish:
     name: Release
     runs-on: ubuntu-latest
+    # Only main auto-releases. Beta releases are cut by manually running
+    # "Generate New Release" with the beta branch selected.
     if: github.ref == 'refs/heads/main'
     needs: [test]
     steps:
@@ -178,4 +144,7 @@ jobs:
         uses: benc-uk/workflow-dispatch@v1
         with:
           workflow: Generate New Release
+          # Without an explicit ref the dispatch runs against the default
+          # branch rather than the branch that triggered it.
+          ref: ${{ github.ref }}
           token: ${{ secrets.GITHUB_TOKEN }}

data/.standard.yml

@@ -1,6 +1,6 @@
 fix: true
 parallel: true
-ruby_version: 2.7
+ruby_version: 3.0
 
 ignore:
   - 'vendor/**/*'

data/Appraisals

@@ -1,18 +1,3 @@
-appraise "rails-5_2" do
-  gem "rails", "~> 5.2.0"
-  gem "rspec-rails"
-  gem "sqlite3", "~> 1.4.0"
-  gem "database_cleaner"
-end
-
-appraise "rails-5_2-graphiti-rails" do
-  gem "rails", "~> 5.2.0"
-  gem "rspec-rails"
-  gem "sqlite3", "~> 1.4.0"
-  gem "database_cleaner"
-  gem "graphiti-rails", "~> 0.4.0"
-end
-
 appraise "rails-6" do
   gem "rails", "~> 6.0"
   gem "rspec-rails"

data/CHANGELOG.md

@@ -1,43 +1,18 @@
 graphiti changelog
 
-## [1.13.4](https://github.com/graphiti-api/graphiti/compare/v1.13.3...v1.13.4) (2026-08-20)
+# [2.0.0-beta.1](https://github.com/graphiti-api/graphiti/compare/v1.12.2...v2.0.0-beta.1) (2026-07-30)
 
 
-### Bug Fixes
-
-* resolve inline when already on a sideload pool thread ([2757dde](https://github.com/graphiti-api/graphiti/commit/2757ddee5728224540c7a3bfa33583fe71c64703))
-* scope debugger chunks to the request rather than the class ([be1d833](https://github.com/graphiti-api/graphiti/commit/be1d83346e4303eaa700c0cbda6b4c60ddf587e7))
-
-## [1.13.3](https://github.com/graphiti-api/graphiti/compare/v1.13.2...v1.13.3) (2026-08-09)
-
-
-### Bug Fixes
-
-* reject invalid page parameters ([#537](https://github.com/graphiti-api/graphiti/issues/537)) ([fbb5683](https://github.com/graphiti-api/graphiti/commit/fbb5683393301e17ffcea84990ac5a95bdd3e15f)), closes [#347](https://github.com/graphiti-api/graphiti/issues/347)
-* treat empty polymorphic configuration as unset ([#538](https://github.com/graphiti-api/graphiti/issues/538)) ([a27eeea](https://github.com/graphiti-api/graphiti/commit/a27eeea6eeb72749376c1f7959cadc89012142b9)), closes [#199](https://github.com/graphiti-api/graphiti/issues/199)
-
-## [1.13.2](https://github.com/graphiti-api/graphiti/compare/v1.13.1...v1.13.2) (2026-08-07)
-
-
-### Bug Fixes
-
-* drop the relationship guard install notice ([65b8be6](https://github.com/graphiti-api/graphiti/commit/65b8be65455a7d034c9dca082434c1dbfe610a7a))
-
-## [1.13.1](https://github.com/graphiti-api/graphiti/compare/v1.13.0...v1.13.1) (2026-08-02)
-
-
-### Bug Fixes
-
-* accept a single value for array filters ([#517](https://github.com/graphiti-api/graphiti/issues/517)) ([23f3e80](https://github.com/graphiti-api/graphiti/commit/23f3e80b583b0bf0843d8bb9334970ae56d83299))
-* typecast null values in filter lists ([#515](https://github.com/graphiti-api/graphiti/issues/515)) ([3dcf4c8](https://github.com/graphiti-api/graphiti/commit/3dcf4c868abb12eb6b6d59cd0814b227d4838ece))
+### Features
 
-# [1.13.0](https://github.com/graphiti-api/graphiti/compare/v1.12.2...v1.13.0) (2026-07-30)
+* drop Ruby 2.7 and Rails 5.2 support ([e905ddb](https://github.com/graphiti-api/graphiti/commit/e905ddb5c842299ffbfe5ec3c4ff98ec9b603a51))
+* the model you inspect is the model that saves ([#465](https://github.com/graphiti-api/graphiti/issues/465)) ([a905fff](https://github.com/graphiti-api/graphiti/commit/a905fffc3a2aa5e663ff4cadcd632e68f053c81a))
 
 
-### Features
+### BREAKING CHANGES
 
-* add Resource.wrap as an easy way to use graphiti serialization on models fetched via other means (and not via graphiti's finders) ([#513](https://github.com/graphiti-api/graphiti/issues/513)) ([fcd19e2](https://github.com/graphiti-api/graphiti/commit/fcd19e2d023091d85947dbdd89259b587e0f582b))
-* deprecate mutating attributes in around_persistence hooks ([#514](https://github.com/graphiti-api/graphiti/issues/514)) [skip ci] ([8410ab0](https://github.com/graphiti-api/graphiti/commit/8410ab0a916077601cf85d8260a05ef9098149eb))
+* around_persistence hooks receive the assigned model instead of the attributes hash. Move attribute-hash modifications to before_attributes, or set values on the model. Custom create/update overrides that should receive a pre-assigned model must accept an assigned_model: keyword. See UPGRADING.md
+* Ruby >= 3.0 / Rails >= 6 are now required.
 
 ## [1.12.2](https://github.com/graphiti-api/graphiti/compare/v1.12.1...v1.12.2) (2026-07-29)
 

data/UPGRADING.md

@@ -0,0 +1,71 @@
+# Upgrading Graphiti
+
+## 1.x to 2.0
+
+### Requirements
+
+Graphiti 2.0 requires Ruby 3.0+ and Rails 6.0+ (when using Rails).
+
+### The model you inspect is the model that saves
+
+Proxies returned by `build` and `find` now apply the request payload lazily, and expose the resulting model before anything is written:
+
+```ruby
+# Creates
+resource = MyResource.build(params)
+resource.data          # unsaved model, attributes applied
+resource.data.valid?   # inspect before committing to anything
+resource.save          # persists that same instance
+
+# Updates
+resource = MyResource.find(params)
+resource.assign_attributes(params)
+resource.data.changed  # dirty tracking works
+resource.update
+
+# or assign and save in one call, Rails-style
+resource = MyResource.find(params)
+resource.update(params)
+```
+
+`assign_attributes` is idempotent per payload, validation still runs before assignment, and the instance you inspect is the instance that saves.
+
+### Breaking: around_persistence receives the model, not the attributes hash
+
+To make the above hold, attributes are assigned to the model once, before the persistence hooks fire. `around_persistence` now wraps the save of an already-assigned model and receives that model:
+
+```ruby
+# 1.x
+def do_around_persistence(attributes)
+  attributes[:tenant_id] = current_tenant.id
+  model = yield
+  model.log_saved!
+end
+
+# 2.0
+def do_around_persistence(model)
+  model.tenant_id = current_tenant.id # last chance to touch the model before save, inside the transaction
+  saved = yield
+  saved.log_saved!
+end
+```
+
+To migrate, move attribute-hash modifications to `before_attributes` (which still receives the mutable hash, before assignment), or set the value on the model as above. Hooks that only wrap their yield - transactions, timing, post-save side effects - need no changes. Graphiti 1.x releases warn at runtime when a hook would be affected.
+
+`before/around/after_attributes` and `before/around/after_save` are unchanged.
+
+### Breaking: custom create/update overrides and pre-assigned models
+
+If a resource overrides `create` or `update` and callers inspect the model before saving, the override must accept the already-assigned model:
+
+```ruby
+def create(attributes, meta = nil, assigned_model: nil)
+```
+
+Without the keyword, saving a proxy whose model was inspected raises `Graphiti::Errors::AssignedModelNotSupported` rather than silently discarding changes made to the inspected instance. Overridden resources used only via plain `save` are unaffected.
+
+### Fine print
+
+- If you inspect the model before saving, the attributes callbacks run at inspection time (in your controller, outside the save transaction). On the plain `save` path they run inside the transaction, at the same point as 1.x.
+- Writable guards judge persisted state: a guard asking for the model gets a fresh build/find, never the current request's unsaved changes. A payload cannot influence its own authorization.
+- Sideposted child models are still built and assigned during save; `data` exposes the pre-assigned root model only.

data/graphiti.gemspec

@@ -16,7 +16,25 @@ 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.7"
+  spec.required_ruby_version = ">= 3.0"
+
+  # TODO: remove once the 1.12 upgrade window has passed
+  spec.post_install_message = <<~MSG
+    Graphiti: relationship readable:/writable: guards are now enforced.
+
+    Symbols, strings, and procs passed to a relationship's readable/writable
+    guards were always interpreted as true and never actually called before this
+    conditional relationship change. They are now evaluated per-request, where
+    unreadable relationships are omitted from responses and includes, and unwritable
+    relationships reject writes.
+
+    To list every affected relationship in your app:
+
+      bin/rails runner 'puts Graphiti.guarded_relationships'
+
+    Audit these before deploying. Apps using schema.json will also see affected 
+    relationships flagged as "became guarded" by the schema check.
+  MSG
 
   spec.add_dependency "jsonapi-serializable", "~> 0.3.0"
   spec.add_dependency "jsonapi-renderer", "~> 0.2", ">= 0.2.2"

data/lib/graphiti/debugger.rb

@@ -4,22 +4,11 @@
 module Graphiti
   class Debugger
     class << self
-      attr_accessor :enabled, :debug_models, :preserve, :pry
+      attr_accessor :enabled, :chunks, :debug_models, :preserve, :pry
     end
-
-    CHUNKS = :__graphiti_debugger_chunks
-    private_constant :CHUNKS
+    self.chunks = []
 
     class << self
-      # Pool threads inherit this through the thread-local copy Scope#future_with_context makes, so their chunks reach the right request.
-      def chunks
-        Thread.current[CHUNKS] ||= Concurrent::Array.new
-      end
-
-      def chunks=(value)
-        Thread.current[CHUNKS] = value
-      end
-
       def on_data(name, start, stop, id, payload)
         return [] unless enabled
 
@@ -190,15 +179,14 @@ module Graphiti
       end
 
       def graph_statements
-        statements = chunks
-        statements.each do |chunk|
+        @chunks.each do |chunk|
           if (parent = chunk[:parent])
-            relevant = statements.find { |c| c[:resource] == parent }
+            relevant = chunks.find { |c| c[:resource] == parent }
             relevant[:children].unshift(chunk) if relevant
           end
         end
-        statements.reject! { |c| !!c[:parent] }
-        statements
+        @chunks.reject! { |c| !!c[:parent] }
+        @chunks
       end
 
       def chunk_to_hash(chunk)

data/lib/graphiti/errors.rb

@@ -84,6 +84,25 @@ module Graphiti
       end
     end
 
+    class AssignedModelNotSupported < Base
+      def initialize(resource_class, method_name)
+        @resource_class = resource_class
+        @method_name = method_name
+      end
+
+      def message
+        <<~MSG
+          #{@resource_class}: the model was already assigned via #assign_attributes (or #data before save), but ##{@method_name} is overridden without a parameter to receive it, so changes made to the unsaved model would be silently lost.
+
+          Accept and use the assigned model in your override:
+
+            def #{@method_name}(attributes, meta = nil, assigned_model: nil)
+
+          or persist with #save alone, without inspecting the model first. See UPGRADING.md.
+        MSG
+      end
+    end
+
     class RemoteWrite < Base
       def initialize(resource_class)
         @resource_class = resource_class
@@ -467,19 +486,6 @@ module Graphiti
       end
     end
 
-    class InvalidWrapModel < Base
-      def initialize(resource_class, model)
-        @resource_class = resource_class
-        @model = model
-      end
-
-      def message
-        <<~MSG
-          #{@resource_class.name}.wrap was given a #{@model.class}, but this resource is for #{@resource_class.model} (subclasses are fine).
-        MSG
-      end
-    end
-
     class ResourceEndpointConflict < Base
       def initialize(path, action, resource_a, resource_b)
         @path = path

data/lib/graphiti/query.rb

@@ -4,6 +4,7 @@ module Graphiti
   class Query
     attr_reader :resource, :association_name, :params, :action
 
+    # TODO: make the trailing optionals keywords once the satellite gems are rolled in - see Runner#query for the nil-padding this forces
     def initialize(resource, params, association_name = nil, nested_include = nil, parents = [], action = nil)
       @resource = resource
       @association_name = association_name

data/lib/graphiti/request_validators/validator.rb

@@ -11,15 +11,12 @@ module Graphiti
       end
 
       def validate
-        validate_page
-
         # Right now, all requests - even reads - go through the validator
         # In the future these should have their own validation logic, but
         # for now we can just bypass
-        return errors.blank? unless @params.has_key?(:data)
+        return true unless @params.has_key?(:data)
 
         resource = @root_resource
-
         if @params[:data].has_key?(:type)
           if (meta_type = deserialized_payload.meta[:type].try(:to_sym))
             if @root_resource.type != meta_type && @root_resource.polymorphic?
@@ -50,13 +47,6 @@ module Graphiti
 
       private
 
-      def validate_page
-        page = @params[:page]
-        return if page.nil? || page.respond_to?(:each_pair)
-
-        @errors.add(:page, :invalid, message: "must be an object")
-      end
-
       def process_relationships(resource, relationships, payload_path)
         relationships.each_key do |name|
           unless resource.class.sideload(name.to_sym)

data/lib/graphiti/resource/configuration.rb

@@ -21,10 +21,6 @@ module Graphiti
           send(:prepend, Polymorphism)
         end
 
-        def polymorphic?
-          polymorphic.present?
-        end
-
         def type=(val)
           val = val&.to_sym
           if (val = super)

data/lib/graphiti/resource/interface.rb

@@ -50,31 +50,11 @@ module Graphiti
         def build(params, base_scope = nil)
           validate_request!(params)
           runner = Runner.new(self, params)
-          runner.proxy(base_scope, single: true, raise_on_missing: true)
-        end
-
-        # Wrap models fetched outside graphiti so they render like any other proxy
-        def wrap(models, base_scope = nil)
-          validate_wrap_models!(models)
-          runner = Runner.new(self, {}, nil, :find)
-          runner.proxy(base_scope, bypass_required_filters: true).tap do |proxy|
-            proxy.data = models
-          end
+          runner.proxy(base_scope, single: true, raise_on_missing: true, assign_action: :create)
         end
 
         private
 
-        # Skip polymorphic parents - resource_for_model raises a better error for unknown children
-        def validate_wrap_models!(models)
-          return if abstract_class? || (polymorphic? && !polymorphic_child?)
-
-          [models].flatten.compact.each do |model|
-            unless model.is_a?(self.model)
-              raise Errors::InvalidWrapModel.new(self, model)
-            end
-          end
-        end
-
         def caching_options
           {cache: @cache_resource, cache_expires_in: @cache_expires_in, cache_tag: @cache_tag}
         end

data/lib/graphiti/resource/persistence.rb

@@ -69,46 +69,57 @@ module Graphiti
         end
       end
 
-      def create(create_params, meta = nil)
-        model_instance = nil
-        snapshot = attributes_snapshot(:create, create_params)
+      # +model_instance+ is the already-built model from a previous #assign
+      # (see ResourceProxy#assign_attributes). When given, attributes are
+      # applied to it rather than to a freshly built/found model.
+      def assign(assign_params, meta = nil, action_name = nil, model_instance: nil)
+        # Only update strips :id (it identifies the record to find) - a create
+        # payload may legitimately carry a client-supplied id to assign.
+        if action_name == :update
+          id = assign_params[:id]
+          assign_params = assign_params.except(:id)
+        end
+
+        run_callbacks :attributes, action_name, assign_params, meta do |params|
+          model_instance ||= if action_name == :update
+            self.class._find(id: id).data
+          else
+            call_with_meta(:build, model, meta)
+          end
+          call_with_meta(:assign_attributes, model_instance, params, meta)
+          model_instance
+        end
 
-        run_callbacks :persistence, :create, create_params, meta do
-          warn_attributes_mutated_in_around_persistence(:create, snapshot, create_params)
+        model_instance
+      end
 
-          run_callbacks :attributes, :create, create_params, meta do |params|
-            model_instance = call_with_meta(:build, model, meta)
-            call_with_meta(:assign_attributes, model_instance, params, meta)
-            model_instance
-          end
+      # Attributes are assigned before the persistence callbacks fire, so
+      # around_persistence receives the assigned model - its pre-yield
+      # position is the last chance to touch the model before save, inside
+      # the transaction. Modify attributes in before_attributes instead.
+      def create(create_params, meta = nil, assigned_model: nil)
+        model_instance = assigned_model || assign(create_params, meta, :create)
 
+        run_callbacks :persistence, :create, model_instance, meta do
           run_callbacks :save, :create, model_instance, meta do
             model_instance = call_with_meta(:save, model_instance, meta)
           end
 
           model_instance
         end
-      end
-
-      def update(update_params, meta = nil)
-        model_instance = nil
-        id = update_params[:id]
-        update_params = update_params.except(:id)
-
-        snapshot = attributes_snapshot(:update, update_params)
 
-        run_callbacks :persistence, :update, update_params, meta do
-          warn_attributes_mutated_in_around_persistence(:update, snapshot, update_params)
+        model_instance
+      end
 
-          run_callbacks :attributes, :update, update_params, meta do |params|
-            model_instance = self.class._find(id: id).data
-            call_with_meta(:assign_attributes, model_instance, params, meta)
-            model_instance
-          end
+      def update(update_params, meta = nil, assigned_model: nil)
+        model_instance = assigned_model || assign(update_params, meta, :update)
 
+        run_callbacks :persistence, :update, model_instance, meta do
           run_callbacks :save, :update, model_instance, meta do
             model_instance = call_with_meta(:save, model_instance, meta)
           end
+
+          model_instance
         end
 
         model_instance
@@ -140,37 +151,6 @@ module Graphiti
 
       private
 
-      # In Graphiti 2.0, attributes are assigned to the model before the
-      # persistence hooks fire, so hash modifications made by an
-      # around_persistence hook before its yield will no longer be applied.
-      # Snapshot-and-compare detects exactly those hooks: the comparison
-      # happens before any attributes-phase callback has run, so hooks that
-      # only wrap their yield never trigger the warning.
-      def attributes_snapshot(action, params)
-        return unless around_persistence_hooks?(action)
-        Util::Hash.deep_dup(params)
-      end
-
-      def around_persistence_hooks?(action)
-        hooks = self.class.config[:callbacks][:persistence].try(:[], :around) || []
-        hooks.any? { |hook| hook[:only].include?(action) }
-      end
-
-      def warn_attributes_mutated_in_around_persistence(action, snapshot, params)
-        return if snapshot.nil? || snapshot == params
-
-        changed_keys = (snapshot.keys | params.keys).reject { |key| snapshot[key] == params[key] }
-        Graphiti::DEPRECATOR.warn(<<~MSG)
-          #{self.class}'s around_persistence hook modified the attributes hash before yield (changed keys: #{changed_keys.map(&:inspect).join(", ")}). In Graphiti 2.0, attributes are assigned to the model before persistence hooks run, and these modifications will be silently ignored. Move the modification to a hook that runs before assignment:
-
-            before_attributes do |attributes|
-              attributes[#{changed_keys.first.inspect}] = ...
-            end
-
-          or set the value on the model itself in a before_save hook. See UPGRADING.md in the Graphiti 2.0 release.
-        MSG
-      end
-
       def run_callbacks(kind, action, *args)
         fire_around_callbacks(kind, action, *args) do |*yieldargs|
           fire_callbacks(kind, :before, action, *yieldargs)

data/lib/graphiti/resource/polymorphism.rb

@@ -8,8 +8,6 @@ module Graphiti
       end
 
       def serializer_for(model)
-        return super unless self.class.polymorphic?
-
         if polymorphic_child?
           serializer
         else
@@ -19,14 +17,10 @@ module Graphiti
       end
 
       def associate_all(*args)
-        return super unless self.class.polymorphic?
-
         _associate(:associate_all, *args)
       end
 
       def associate(*args)
-        return super unless self.class.polymorphic?
-
         _associate(:associate, *args)
       end
 
@@ -40,8 +34,6 @@ module Graphiti
 
       module ClassMethods
         def inherited(klass)
-          return super unless polymorphic?
-
           klass.type = nil
           klass.model = klass.infer_model
           klass.endpoint = klass.infer_endpoint
@@ -50,8 +42,6 @@ module Graphiti
         end
 
         def sideload(name)
-          return super unless polymorphic?
-
           if (split_on = name.to_s.split(/^on__/)).length > 1
             on_type, name = split_on[1].split("--").map(&:to_sym)
           end