graphiti 2.0.0.beta.10 → 2.0.0.beta.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1e331ab2dea47987ea47260eb0890c9a953d3435bba2e7ef37cbfbbc83fe5ab
-  data.tar.gz: 13a7483ead9f4ad5ed69390ff6a4a122a819813c2147c0a56dceebdfebc57e17
+  metadata.gz: 6e73d0272cfabe57d3eb0cbc82ad7199dea624afead6856ca72c1107857fa144
+  data.tar.gz: 795ddb1e77c8f61d2e74c66c333ccc4acd5c37ccb6aa3b4c7cb816f52dfe1b71
 SHA512:
-  metadata.gz: cca252389b52b5a2983407b4eff7cf7fe8b49759b478228f9d78303522bc40f2948a1784d6c863373f10521dc80b61d35f201009e830d8a968cc989b37d2ad81
-  data.tar.gz: 3fdfda722d09ddea6c366ca4102258bdea6d36c923be729ae141063e7e62b43ae0730f30a6422ae4448f858a5c1d4269f80180279d7939ce050c88008613cedb
+  metadata.gz: f5ff1c0630702209372d0512afd16d29c87d6f561c551e08a5080bd25efa8b3bae465d33729129289a3ade41db781b779bffd753b55f6cf7cf02389662fa835e
+  data.tar.gz: '0785ff7bd32570ef7bf588c7287b4704d7f9daf50bafb47f0739f02b054086a297cef4427364f818b5ab540a72935447bead5898957f597a400a40b435f4a81f'

data/.github/workflows/ci.yml

@@ -85,6 +85,12 @@ jobs:
           bundler-cache: true
       - name: Run tests
         run: bundle exec rspec
+      # spec_helper narrows "bundle exec rspec" to spec/integration/rails when
+      # APPRAISAL_INITIALIZED is set, so the step above never runs the library
+      # suite. This is the only cell that runs it against a pinned Rails.
+      - name: Run the library suite against this Rails
+        if: matrix.appraisal
+        run: env -u APPRAISAL_INITIALIZED bundle exec rspec
   example-app:
     name: "Example app (employee_directory)"
     runs-on: ubuntu-latest

data/.github/workflows/release.yml

@@ -13,6 +13,8 @@ jobs:
         uses: actions/checkout@v5
         with:
           persist-credentials: false
+          # semantic-release reads the tag history to work out the next version
+          fetch-depth: 0
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:

data/.tool-versions

@@ -1 +1 @@
-ruby 3.3.4
+ruby 4.0.6

data/CHANGELOG.md

@@ -1,5 +1,44 @@
 graphiti changelog
 
+# [2.0.0-beta.12](https://github.com/graphiti-api/graphiti/compare/v2.0.0-beta.11...v2.0.0-beta.12) (2026-08-30)
+
+
+### Bug Fixes
+
+* compare each concurrency path against itself in the table to better illustrate the performance wins ([d0f0e92](https://github.com/graphiti-api/graphiti/commit/d0f0e92860b3b4affe3fca6dbb9b871fe8a1374f))
+
+
+### Features
+
+* add schema rake tasks, so checking a schema no longer means running the suite ([6f4783d](https://github.com/graphiti-api/graphiti/commit/6f4783d5654659125b7eb358bf1175b6feaacb7c))
+* declare Graphiti's client errors in rescue_responses ([e369824](https://github.com/graphiti-api/graphiti/commit/e369824d6e11b671ffd212caad3d0a43a7ceefcf))
+* mark deprecated settings in the generated ApplicationResource ([52b0642](https://github.com/graphiti-api/graphiti/commit/52b0642e689a16d14dacaf4e28a2641f10774cf0))
+* take error text from locale keys ([d01fd06](https://github.com/graphiti-api/graphiti/commit/d01fd06fc1ede8c3dd798ec48de4d5b01645d87e)), closes [#216](https://github.com/graphiti-api/graphiti/issues/216)
+
+# [2.0.0-beta.11](https://github.com/graphiti-api/graphiti/compare/v2.0.0-beta.10...v2.0.0-beta.11) (2026-08-27)
+
+
+### Bug Fixes
+
+* always render included when the client asked to include ([8691b3f](https://github.com/graphiti-api/graphiti/commit/8691b3fd08f3cae0481ba72839911fdc71ef5634))
+* autolink = true no longer clobbers an inherited :on_demand ([2d26f8c](https://github.com/graphiti-api/graphiti/commit/2d26f8cb567e82a16918345de9114b8ceef64523))
+* read the links param from the query, not the context object ([3b934cb](https://github.com/graphiti-api/graphiti/commit/3b934cb25be049e1e80ba400123da944cfd23d04))
+* stop assigning the same child twice when a resource repeats in the include path ([588503b](https://github.com/graphiti-api/graphiti/commit/588503b109508495d8170373d80019c6971f7d9c))
+
+
+### Features
+
+* omit relationships that render no ids and no link ([916aa8c](https://github.com/graphiti-api/graphiti/commit/916aa8c9c596c5d9b6c802c5ab13b766a13d1e70))
+
+
+### Performance Improvements
+
+* memoize whether a belongs_to renders ids from its foreign key ([dcb60b2](https://github.com/graphiti-api/graphiti/commit/dcb60b2096c414756ccff534773d2e45594f0144))
+* only deduplicate resources that two include paths can both reach ([744f014](https://github.com/graphiti-api/graphiti/commit/744f014249382bc25d5ea43f692778ad7adc25c3))
+* resolve a lone sideload inline rather than through the pool ([3415592](https://github.com/graphiti-api/graphiti/commit/3415592d75900389a8f11f53b65ab399e297e4a9))
+* reuse the resolved data and proxies when building cache keys ([8a17350](https://github.com/graphiti-api/graphiti/commit/8a17350542ba0062fdcddd115afe8041b62198c7))
+* skip the on-demand link strip when no relationship renders links on demand ([cf86a8c](https://github.com/graphiti-api/graphiti/commit/cf86a8c249077d9f9d5a13de49989d102bbaed04))
+
 # [2.0.0-beta.10](https://github.com/graphiti-api/graphiti/compare/v2.0.0-beta.9...v2.0.0-beta.10) (2026-08-24)
 
 

data/Rakefile

@@ -11,31 +11,36 @@ RSpec::Core::RakeTask.new(:spec) do |t|
   end
 end
 
+# Allocations mean the same anywhere and timings do not, so the history has a
+# reference CPU, named on every row, and recording timings refuses to mix them.
 namespace :performance do
   # Shelling out keeps a failure to the script's own message, with no rake backtrace on top.
   def measure(*arguments)
     exit(1) unless system("bundle", "exec", "ruby", "spec/performance/measure_releases.rb", *arguments)
   end
 
-  desc "Compare the working tree to the last release, and plot it"
-  task :current do
-    measure
+  desc "Read a change: measure the working tree, print the comparison and plot it"
+  task :read do
+    measure("--read")
   end
 
-  desc "Plot the release history plus the working tree to tmp/performance.html and open it"
-  task :page do
-    exit(1) unless system("bundle", "exec", "ruby", "spec/performance/chart_page.rb")
+  desc "Open the recorded history as a chart. Any machine, measures nothing"
+  task :chart do
+    exit(1) unless system("bundle", "exec", "ruby", "spec/performance/chart_page.rb", "--no-current")
   end
 
-  desc "Measure one release and record it (TAG=v2.0.0-beta.9)"
+  desc "Fill in the history. Missing releases by default, TAG=v2.0.0-beta.9 for one, ALL=1 for every. Reference CPU"
   task :record do
-    tag = ENV["TAG"] or abort "pass the release to record, e.g. rake performance:record TAG=v2.0.0-beta.9"
-    measure(tag)
+    measure(*(if ENV["TAG"]
+                [ENV["TAG"]]
+              else
+                ENV["ALL"] ? ["--all"] : ["--missing"]
+              end))
   end
 
-  desc "Re-record every release for this ruby, replacing its rows"
-  task :record_all do
-    measure("--all")
+  desc "Measure the working tree for the release to name, and commit it. Reference CPU"
+  task :pending do
+    measure("--pending")
   end
 end
 

data/lib/generators/graphiti/generator_mixin.rb

@@ -50,11 +50,12 @@ module Graphiti
     end
 
     def resource_setting_hint(setting)
-      return setting[:note] if setting[:note]
-      return unless setting[:values]
+      hint = setting[:note] || setting[:values]&.map(&:inspect)
+        &.to_sentence(two_words_connector: " or ", last_word_connector: ", or ")
 
-      setting[:values].map(&:inspect)
-        .to_sentence(two_words_connector: " or ", last_word_connector: ", or ")
+      return hint unless setting[:deprecated]
+
+      ["deprecated, removed in 3.0", hint].compact.join(". ")
     end
 
     def graphiti_config

data/lib/generators/graphiti/install_generator.rb

@@ -1,4 +1,5 @@
 require_relative "generator_mixin"
+require_relative "locale_generator"
 
 module Graphiti
   class InstallGenerator < ::Rails::Generators::Base
@@ -17,6 +18,8 @@ module Graphiti
       to = File.join("app/resources", "application_resource.rb")
       template("application_resource.rb.erb", to)
 
+      invoke(Graphiti::LocaleGenerator, [], options)
+
       inject_into_file "app/controllers/application_controller.rb", after: "class ApplicationController < ActionController::API\n" do
         app_controller_code
       end

data/lib/generators/graphiti/locale_generator.rb

@@ -0,0 +1,30 @@
+module Graphiti
+  class LocaleGenerator < ::Rails::Generators::Base
+    source_root File.expand_path("templates", __dir__)
+
+    class_option :"omit-comments",
+      type: :boolean,
+      default: false,
+      aliases: ["-c"],
+      desc: "Generate without documentation comments"
+
+    desc "Writes the error text Graphiti renders, ready to edit"
+    def locale
+      template("locale.yml.erb", File.join("config/locales", "graphiti.en.yml"))
+    end
+
+    private
+
+    def omit_comments?
+      @options["omit-comments"]
+    end
+
+    def default_messages
+      Graphiti::Util::SimpleErrors::DEFAULT_MESSAGES
+    end
+
+    def default_format
+      Graphiti::Util::SimpleErrors::DEFAULT_FORMAT
+    end
+  end
+end

data/lib/generators/graphiti/templates/locale.yml.erb

@@ -0,0 +1,22 @@
+<%- unless omit_comments? -%>
+# Everything Graphiti puts in an errors payload.
+# For another language, add a block below or a graphiti.<locale>.yml file.
+<%- end -%>
+en:
+  graphiti:
+    errors:
+<%- unless omit_comments? -%>
+      # Titles and details are keyed by error code, and Graphiti ships none.
+      # Without a key you get the HTTP status name and no detail.
+      #
+      # internal_server_error:
+      #   title: "Something went wrong"
+      #   detail: "We've probably received an error report already, but please contact us if the issue persists."
+      #
+      # format joins them: "data.attributes.title is an unknown attribute".
+<%- end -%>
+      format: <%= default_format.inspect %>
+      messages:
+<%- default_messages.each do |code, message| -%>
+        <%= code %>: <%= message.inspect %>
+<%- end -%>

data/lib/graphiti/adapters/abstract.rb

@@ -371,10 +371,11 @@ module Graphiti
           activerecord_adapter.associate \
             parent, child, association_name, association_type
         elsif [:has_many, :many_to_many].include?(association_type)
-          if parent.send(:"#{association_name}").nil?
+          associated = parent.send(:"#{association_name}")
+          if associated.nil?
             parent.send(:"#{association_name}=", [child])
-          else
-            parent.send(:"#{association_name}") << child
+          elsif associated.none? { |existing| existing.equal?(child) }
+            associated << child
           end
         else
           parent.send(:"#{association_name}=", child)

data/lib/graphiti/error_serializers/conflict_request.rb

@@ -11,7 +11,7 @@ module Graphiti
         "conflict"
       end
 
-      def title
+      def default_title
         "Conflict Error"
       end
     end

data/lib/graphiti/error_serializers/deprecated_constants.rb

@@ -1,25 +1,15 @@
-# The graphiti_errors gem was absorbed into graphiti in 2.0. Only its
-# serializers survived, as Graphiti::ErrorSerializers. The rest of it (the
-# GraphitiErrors controller mixin and its exception handlers) is replaced by
-# rescue_registry rather than renamed, so there is deliberately nothing here to
-# alias it to. A custom error renderer reaching for one of the serializers gets
-# pointed at the new name instead of a bare NameError. Remove in 3.0.
+# Only graphiti_errors' serializers survived the 2.0 merge. Remove in 3.0.
 module GraphitiErrors
-  # `include GraphitiErrors` in ApplicationController was this gem's headline
-  # usage. Including an empty module succeeds, so without this an upgraded app
-  # boots clean and then serves Rails' default HTML error pages instead of
-  # JSON:API ones, with nothing to indicate why.
+  # Including an empty module succeeds, so silence here means HTML error pages.
   def self.included(klass)
     raise <<~MSG
-      GraphitiErrors was merged into graphiti as of 2.0 and `include GraphitiErrors`
-      no longer does anything.
-
-      Exception handling now goes through rescue_registry. Replace it with:
+      GraphitiErrors merged into graphiti in 2.0 and this include does nothing. Use:
 
         include Graphiti::Rails::Controller
 
-      which registers Graphiti's own handlers. Your own go alongside them with
-      `register_exception`, available on every controller.
+      Your own exceptions register alongside Graphiti's with `register_exception`.
+      `registered_exception?` is now `RescueRegistry.handles_exception?`, and
+      `handle_exception` went with the rendering. See graphiti.dev/upgrading.
     MSG
   end
 

data/lib/graphiti/error_serializers/invalid_request.rb

@@ -49,6 +49,12 @@ module Graphiti
       end
 
       def title
+        return default_title unless defined?(::I18n)
+
+        ::I18n.t :title, scope: [:graphiti, :errors, code], default: default_title
+      end
+
+      def default_title
         "Request Error"
       end
 

data/lib/graphiti/errors.rb

@@ -719,11 +719,11 @@ module Graphiti
 
       def message
         <<~MSG
-          #{@resource_class.name}: #{@attribute} must be one of :as_literal, :as_nil, or :reject. Got #{@value.inspect}.
+          #{@resource_class.name}: #{@attribute} must be one of :literal, :null, or :rejected. Got #{@value.inspect}.
 
-            :as_literal - "null" and "" reach the filter as strings (default)
-            :as_nil     - "null" becomes nil, so the filter can query for NULL
-            :reject     - a blank value raises InvalidFilterValue
+            :literal  - "null" and "" reach the filter as strings (default)
+            :null     - "null" becomes nil, so the filter can query for NULL
+            :rejected - a blank value raises InvalidFilterValue
         MSG
       end
     end

data/lib/graphiti/query.rb

@@ -39,10 +39,37 @@ module Graphiti
       @entity_map
     end
 
+    # Deduplication exists for a row two include paths both resolve, so a
+    # resource class sitting at one node has nothing to collide with.
+    def repeated_resource_classes
+      return root.repeated_resource_classes unless root == self
+
+      @repeated_resource_classes ||= begin
+        counts = Hash.new(0)
+        walk = [self]
+        while (query = walk.pop)
+          counts[query.resource.class] += 1
+          query.sideloads.each_pair do |name, sideload_query|
+            walk << sideload_query
+            sideload = query.resource.class.sideload(name)
+            next unless sideload.respond_to?(:children)
+
+            # A polymorphic child resolves under a class no node names.
+            sideload.children.each_value { |child| counts[child.resource.class] += 2 }
+          end
+        end
+        counts.select { |_, count| count > 1 }.keys.to_set
+      end
+    end
+
     def top_level?
       !association?
     end
 
+    def includes_requested?
+      @include_param.present?
+    end
+
     def links_requested?
       return @links_requested if defined?(@links_requested)
 

data/lib/graphiti/rails/exception_handlers.rb

@@ -40,6 +40,23 @@ module Graphiti
         end
         super
       end
+
+      private
+
+      def title_from_status
+        translate(:title) || super
+      end
+
+      # rescue_registry's default tells the client its engineers have been notified.
+      def default_detail_for_status
+        translate(:detail)
+      end
+
+      def translate(key)
+        return unless defined?(::I18n)
+
+        ::I18n.t key, scope: [:graphiti, :errors, error_code], default: nil
+      end
     end
 
     class FallbackHandler < ExceptionHandler

data/lib/graphiti/rails/railtie.rb

@@ -20,6 +20,16 @@ module Graphiti
         load File.expand_path("../../tasks/graphiti.rake", __dir__)
       end
 
+      # ActionDispatch has already copied config.action_dispatch.rescue_responses into the wrapper by now.
+      initializer "graphiti-rails.rescue_responses", after: "action_dispatch.configure" do
+        responses = ActionDispatch::ExceptionWrapper.rescue_responses
+
+        Graphiti::Rails::CLIENT_ERROR_STATUSES.each do |exception, status|
+          # rescue_responses answers :internal_server_error for a missing key, so ||= never assigns.
+          responses[exception] = status unless responses.key?(exception)
+        end
+      end
+
       initializer "graphiti-rails.config" do |app|
         Graphiti::Rails.handled_exception_formats = app.config.graphiti.handled_exception_formats
         Graphiti::Rails.respond_to_formats = app.config.graphiti.respond_to_formats

data/lib/graphiti/rails/rake_helpers.rb

@@ -15,6 +15,11 @@ module Graphiti
         @session ||= ActionDispatch::Integration::Session.new(::Rails.application)
       end
 
+      # An engine runs the task from its own directory, not the host application's root.
+      def schema_path(path = nil)
+        path.nil? ? Graphiti.config.schema_path : File.expand_path(path, Dir.pwd)
+      end
+
       def setup_rails!
         ::Rails.application.eager_load!
         ::Rails.application.config.cache_classes = true

data/lib/graphiti/rails.rb

@@ -38,6 +38,24 @@ module Graphiti
       DEPRECATOR
     )
 
+    # Rails reports an exception to the error reporter unless its rescue_responses names it.
+    CLIENT_ERROR_STATUSES = {
+      "Graphiti::Errors::InvalidRequest" => :bad_request,
+      "Graphiti::Errors::RemoteWrite" => :bad_request,
+      "Graphiti::Errors::SingularSideload" => :bad_request,
+      "Graphiti::Errors::InvalidInclude" => :bad_request,
+      "Graphiti::Errors::UnsupportedSort" => :bad_request,
+      "Graphiti::Errors::UnsupportedOperator" => :bad_request,
+      "Graphiti::Errors::InvalidFilterValue" => :bad_request,
+      "Graphiti::Errors::RequiredFilter" => :bad_request,
+      "Graphiti::Errors::UnsupportedPageSize" => :bad_request,
+      "Graphiti::Errors::UnsupportedBeforeCursor" => :bad_request,
+      "Graphiti::Errors::UnsupportedPagination" => :bad_request,
+      "Graphiti::Errors::FilterGroupMissingRequiredFilters" => :bad_request,
+      "Graphiti::Errors::RecordNotFound" => :not_found,
+      "Graphiti::Errors::ConflictRequest" => :conflict
+    }.freeze
+
     # @!attribute self.handled_exception_formats
     # A list of formats as symbols whose exceptions will be handled by Graphiti. See {Railtie}.
     cattr_accessor :handled_exception_formats, default: []

data/lib/graphiti/renderer.rb

@@ -13,8 +13,11 @@ module Graphiti
       @records ||= @proxy.data
     end
 
+    # JSON:API requires the key even when the include turns up nothing.
     def to_jsonapi
-      render(self.class.jsonapi_renderer).to_json
+      rendered = render(self.class.jsonapi_renderer)
+      rendered[:included] ||= [] if proxy.query.includes_requested?
+      rendered.to_json
     end
 
     def as_graphql

data/lib/graphiti/request_validators/update_validator.rb

@@ -13,11 +13,7 @@ module Graphiti
 
       def attribute_mismatch(attr_path)
         @error_class = Graphiti::Errors::ConflictRequest
-        @errors.add(
-          attr_path.join("."),
-          :attribute_mismatch,
-          message: "does not match the server endpoint"
-        )
+        @errors.add(attr_path.join("."), :attribute_mismatch)
       end
 
       def required_payload?

data/lib/graphiti/request_validators/validator.rb

@@ -54,14 +54,14 @@ module Graphiti
         page = @params[:page]
         return if page.nil? || page.respond_to?(:each_pair)
 
-        @errors.add(:page, :invalid, message: "must be an object")
+        @errors.add(:page, :invalid)
       end
 
       def validate_data_shape
         data = @params[:data]
         return true if data.nil? || data.respond_to?(:each_pair)
 
-        @errors.add(:data, :invalid, message: "must be an object")
+        @errors.add(:data, :invalid)
         false
       end
 
@@ -69,7 +69,7 @@ module Graphiti
         relationships.each_key do |name|
           unless resource.class.sideload(name.to_sym)
             full_key = fully_qualified_key(name, payload_path, :relationships)
-            @errors.add(full_key, :invalid_relationship, message: "is not a valid relationship")
+            @errors.add(full_key, :invalid_relationship)
           end
         end
 
@@ -110,11 +110,11 @@ module Graphiti
             begin
               attributes[key] = resource.typecast(key, value, :writable)
             rescue Graphiti::Errors::UnknownAttribute
-              @errors.add(fully_qualified_key(key, payload_path), :unknown_attribute, message: "is an unknown attribute")
+              @errors.add(fully_qualified_key(key, payload_path), :unknown_attribute)
             rescue Graphiti::Errors::InvalidAttributeAccess
-              @errors.add(fully_qualified_key(key, payload_path), :unwritable_attribute, message: "cannot be written")
+              @errors.add(fully_qualified_key(key, payload_path), :unwritable_attribute)
             rescue Graphiti::Errors::TypecastFailed => e
-              @errors.add(fully_qualified_key(key, payload_path), :type_error, message: "should be type #{e.type_name}")
+              @errors.add(fully_qualified_key(key, payload_path), :type_error, type: e.type_name)
             end
           end
         end

data/lib/graphiti/resource/configuration.rb

@@ -6,7 +6,7 @@ module Graphiti
       DEFAULT_MAX_PAGE_SIZE = 1_000
       LINK_MODES = [true, false, :on_demand].freeze
       BELONGS_TO_RESOURCE_IDS_MODES = [:foreign_key, :always, :never].freeze
-      BLANK_MODES = [:as_literal, :as_nil, :reject].freeze
+      BLANK_MODES = [:literal, :null, :rejected].freeze
 
       # Grouped for the ApplicationResource the install generator writes.
       SETTING_GROUPS = { # :nodoc:
@@ -21,6 +21,7 @@ module Graphiti
         relationships: {
           relationships_readable_by_default: {default: true},
           relationships_writable_by_default: {default: true},
+          relationship_placeholders: {default: false, note: "render placeholders for relationships with no ids and no link"},
           belongs_to_resource_ids_by_default: {
             default: :foreign_key,
             values: BELONGS_TO_RESOURCE_IDS_MODES,
@@ -28,10 +29,10 @@ module Graphiti
           }
         },
         filters: {
-          filters_blanks_by_default: {
-            default: :as_literal,
+          filter_blanks_treated_as: {
+            default: :literal,
             values: BLANK_MODES,
-            invalid: ->(klass, value) { Errors::InvalidFilterBlanks.new(klass, :filters_blanks_by_default, value) }
+            invalid: ->(klass, value) { Errors::InvalidFilterBlanks.new(klass, :filter_blanks_treated_as, value) }
           }
         },
         sorting: {
@@ -194,21 +195,21 @@ module Graphiti
       end
 
       class_methods do
-        # Deprecated. Both folded into filters_blanks_by_default. Remove in 3.0.
+        # Deprecated. Both folded into filter_blanks_treated_as. Remove in 3.0.
         def filters_accept_nil_by_default
-          filters_blanks_by_default == :as_nil
+          filter_blanks_treated_as == :null
         end
 
         def filters_accept_nil_by_default=(val)
-          self.filters_blanks_by_default = val ? :as_nil : :as_literal
+          self.filter_blanks_treated_as = val ? :null : :literal
         end
 
         def filters_deny_empty_by_default
-          filters_blanks_by_default == :reject
+          filter_blanks_treated_as == :rejected
         end
 
         def filters_deny_empty_by_default=(val)
-          self.filters_blanks_by_default = val ? :reject : :as_literal
+          self.filter_blanks_treated_as = val ? :rejected : :literal
         end
 
         # Deprecated. Renamed to the page_ family. Remove in 3.0.
@@ -416,7 +417,7 @@ module Graphiti
       end
     end
 
-    blanks_msg = "Use `self.filters_blanks_by_default` (:as_literal, :as_nil, or :reject)"
+    blanks_msg = "Use `self.filter_blanks_treated_as` (:literal, :null, or :rejected)"
     page_msg = "Use `self.page_default_size`, `self.page_max_size` and `self.page_cursors`"
     DEPRECATOR.deprecate_methods(Configuration::ClassMethods,
       filters_accept_nil_by_default: blanks_msg,

data/lib/graphiti/resource/dsl.rb

@@ -208,16 +208,16 @@ module Graphiti
 
         def blanks_for(name, opts)
           if opts.key?(:deny_empty)
-            DEPRECATOR.warn("The deny_empty: filter option is deprecated. Use blanks: :reject.")
-            return :reject if opts[:deny_empty]
+            DEPRECATOR.warn("The deny_empty: filter option is deprecated. Use blanks: :rejected.")
+            return :rejected if opts[:deny_empty]
           end
 
           if opts.key?(:allow_nil)
-            DEPRECATOR.warn("The allow_nil: filter option is deprecated. Use blanks: :as_nil.")
-            return opts[:allow_nil] ? :as_nil : :as_literal
+            DEPRECATOR.warn("The allow_nil: filter option is deprecated. Use blanks: :null.")
+            return opts[:allow_nil] ? :null : :literal
           end
 
-          blanks = opts.fetch(:blanks, filters_blanks_by_default)
+          blanks = opts.fetch(:blanks, filter_blanks_treated_as)
           unless Resource::BLANK_MODES.include?(blanks)
             raise Errors::InvalidFilterBlanks.new(self, name, blanks)
           end

data/lib/graphiti/resource/links.rb

@@ -39,7 +39,10 @@ module Graphiti
         relationship_links != false
       end
 
+      # true cannot express :on_demand, so it leaves an inherited on-demand mode alone.
       def autolink=(val)
+        return if val && relationship_links == :on_demand
+
         self.relationship_links = val ? true : false
       end