graphiti 2.0.0.beta.11 → 2.0.0.beta.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a639e421891e5d5e650d2d8131a75905cb9ffd0fb40cdfd15239ca5caf29d12f
-  data.tar.gz: 95172bbff224d598c959d5acc93c30861e01c50540fdea871ea5029473bf5259
+  metadata.gz: 2963ad9851cf238b3885921c2b4858bf3b7aefe1fad5726a588c966da8cd0ada
+  data.tar.gz: 6486ac49fff4aa22faaa46cc2aef5439a015943748fd323288c8f90f596fbf9a
 SHA512:
-  metadata.gz: 24c275cfcaecdba9ced126b7970b37962998673a3a8609c885a69befc53adba646ec2c7d9517198509e358ebba5300f3b336c86f02df98af9d18a6f4a4c306c3
-  data.tar.gz: e7d2fd4e0d0ff74b68ea4d3673399d1b72897ad7c8647fa38835ff2b58c850d58ba95a1145a52f55893e88e36eb0aa90bece72a2e6e593173661d16100666edc
+  metadata.gz: b25b468d3ddf0efc6aa513940ae06c2cc30150e7d4a743bd5ba1d4a56a768f3a7452780b515bbd68610ab51bdd979d577f7644d83a0fa724e975a45a547e1bef
+  data.tar.gz: 02a6b4f82e8e7c2d9582c8765d49ef07901e001ea942846d3b70f79ea25c7e83d4d032c5644404420c075e0565eb946cfb1d54356ed319aefb2841e644bb0944

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/CHANGELOG.md

@@ -1,5 +1,44 @@
 graphiti changelog
 
+# [2.0.0-beta.13](https://github.com/graphiti-api/graphiti/compare/v2.0.0-beta.12...v2.0.0-beta.13) (2026-08-31)
+
+
+### Bug Fixes
+
+* compare the endpoint id to the payload id as strings ([62051d7](https://github.com/graphiti-api/graphiti/commit/62051d7531432357db7bc464cce77ccc55168d07))
+* evaluate writable guards under the action being performed ([d56b86a](https://github.com/graphiti-api/graphiti/commit/d56b86a5ffaac4106aaea1e2ee5400069a4205fe))
+* **generators:** stop injecting a routes host into config/application.rb ([db92d06](https://github.com/graphiti-api/graphiti/commit/db92d0649ca0246662a86b1172229eaa2a817d2b))
+* keep a belongs_to linkage when another include shares its name ([2c9c7c7](https://github.com/graphiti-api/graphiti/commit/2c9c7c7ac06cd319ac95e1445eb55a0322841de2))
+* keep deep filters narrow when an include path repeats ([833a10b](https://github.com/graphiti-api/graphiti/commit/833a10be120a4f2cd615ad05f750c7f246d62801))
+* keep request state in fiber storage so it survives into child fibers ([6569935](https://github.com/graphiti-api/graphiti/commit/6569935c2140d4dd91cd6d4a7f9ec7c1bd05c888))
+* only register the jsonapi mime type when it is missing ([88401ab](https://github.com/graphiti-api/graphiti/commit/88401abc8c77f1e859b4b8da3f9574c75834eb43))
+* with_options accepts the predicate backed relationship options ([71ab441](https://github.com/graphiti-api/graphiti/commit/71ab4418bccc4cff7e6cc10151c1728641d25d34))
+
+
+### Features
+
+* write every error code Graphiti renders into the generated locale file ([15f19c1](https://github.com/graphiti-api/graphiti/commit/15f19c1dbe56559d9d041fa50e2cc5ea7b2dcf4b))
+
+
+### Performance Improvements
+
+* record latest performance stats ([7380ef9](https://github.com/graphiti-api/graphiti/commit/7380ef912e9f3b99618bf47ed04e06d1efad4e6c))
+
+# [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)
 
 

data/Gemfile

@@ -3,6 +3,9 @@ source "https://rubygems.org"
 # Specify your gem's dependencies in graphiti.gemspec
 gemspec
 
+# Until rescue_registry 1.1 ships with the fiber storage fix.
+gem "rescue_registry", github: "wagenet/rescue_registry", branch: "develop"
+
 group :test do
   gem "database_cleaner"
   gem "pry"

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
@@ -25,23 +28,8 @@ module Graphiti
         app_controller_code
       end
 
-      inject_into_file "config/application.rb", after: "Rails::Application\n" do
-        <<-'RUBY'
-    # In order for Graphiti to generate links, you need to set the routes host.
-    # When not explicitly set, via the HOST env var, this will fall back to
-    # the rails server settings.
-    # Rails::Server is not defined in console or rake tasks, so this will only
-    # use those defaults when they are available.
-    routes.default_url_options[:host] = ENV.fetch('HOST') do
-      if defined?(Rails::Server)
-        argv_options = Rails::Server::Options.new.parse!(ARGV)
-        "http://#{argv_options[:Host]}:#{argv_options[:Port]}"
-      end
-    end
-        RUBY
-      end
-
-      if defined?(RSpec)
+      # Thor aborts the whole generator when this file is missing.
+      if defined?(RSpec) && File.exist?(File.join(destination_root, "spec/rails_helper.rb"))
         inject_into_file "spec/rails_helper.rb", after: /RSpec.configure.+^end$/m do
           <<~RUBY
 
@@ -57,20 +45,7 @@ module Graphiti
       end
 
       insert_into_file "config/routes.rb", after: "Rails.application.routes.draw do\n" do
-        if defined?(VandalUi)
-          <<-STR
-  scope path: ApplicationResource.endpoint_namespace, defaults: { format: :jsonapi } do
-    mount VandalUi::Engine, at: '/vandal'
-    # your routes go here
-  end
-          STR
-        else
-          <<-STR
-  scope path: ApplicationResource.endpoint_namespace, defaults: { format: :jsonapi } do
-    # your routes go here
-  end
-          STR
-        end
+        namespace_scope
       end
     end
 
@@ -80,6 +55,15 @@ module Graphiti
       @options["omit-comments"]
     end
 
+    # The resource generator re-finds this scope by its format default.
+    def namespace_scope
+      lines = ["  scope path: \"#{api_namespace}\", defaults: {format: :jsonapi} do\n"]
+      lines << "    mount VandalUi::Engine, at: '/vandal'\n" if defined?(VandalUi)
+      lines << "    # your routes go here\n"
+      lines << "  end\n"
+      lines.join
+    end
+
     def app_controller_code
       str = +"  include Graphiti::Rails::Controller\n"
       if defined?(::Responders)

data/lib/generators/graphiti/locale_generator.rb

@@ -0,0 +1,86 @@
+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"
+
+    # Every code Graphiti renders a title for, and the title it renders today.
+    ERROR_TITLES = {
+      bad_request: "Request Error",
+      not_found: "Not Found",
+      conflict: "Conflict Error",
+      unprocessable_entity: "Validation Error",
+      internal_server_error: "Internal Server Error"
+    }.freeze
+
+    # The two codes no registration produces.
+    ERROR_SOURCES = {
+      unprocessable_entity: ["a write that failed model validations"],
+      internal_server_error: ["any exception Graphiti did not register"]
+    }.freeze
+
+    # Written into the app's locale file, not defaulted in Graphiti.
+    ERROR_DETAILS = {
+      internal_server_error: "We've probably received an error report already, but please contact us if the issue persists."
+    }.freeze
+
+    COMMENT_WIDTH = 68
+
+    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 error_titles
+      ERROR_TITLES
+    end
+
+    def error_detail(code)
+      ERROR_DETAILS[code]
+    end
+
+    # What raises this code, so the file says where its text is used.
+    def error_source_lines(code)
+      ERROR_SOURCES[code] || wrap(exception_names(code))
+    end
+
+    def exception_names(code)
+      Graphiti::Rails::CLIENT_ERROR_STATUSES
+        .select { |_exception, status| status == code }
+        .keys.map { |exception| exception.delete_prefix("Graphiti::Errors::") }
+    end
+
+    def wrap(names)
+      items = names.map.with_index do |name, index|
+        (index == names.length - 1) ? name : "#{name},"
+      end
+
+      items.each_with_object([]) do |item, lines|
+        joined = "#{lines.last} #{item}"
+        if lines.empty? || joined.length > COMMENT_WIDTH
+          lines << item
+        else
+          lines[-1] = joined
+        end
+      end
+    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/resource_generator.rb

@@ -171,7 +171,8 @@ module Graphiti
       code << %(, controller: "#{controller_path}") if options[:controller]
       code << %(, only: [#{actions.map { |a| ":#{a}" }.join(", ")}]) if actions.length < 5
       code << "\n"
-      inject_into_file "config/routes.rb", after: /ApplicationResource.*$\n/ do
+      # Matches the install generator's scope, including its pre-2.0 form.
+      inject_into_file "config/routes.rb", after: /format: :jsonapi.*$\n/ do
         indent(code, 4)
       end
     end

data/lib/generators/graphiti/templates/application_resource.rb.erb

@@ -1,21 +1,18 @@
 <%- unless omit_comments? -%>
-# ApplicationResource is similar to ApplicationRecord - a base class that
-# holds configuration/methods for subclasses.
 # All Resources should inherit from ApplicationResource.
 <%- end -%>
 class ApplicationResource < Graphiti::Resource
-  <%- unless omit_comments? -%>
-  # Use the ActiveRecord Adapter for all subclasses.
-  # Subclasses can still override this default.
-  <%- end -%>
   self.abstract_class = true
   self.adapter = Graphiti::Adapters::ActiveRecord
-  self.base_url = Rails.application.routes.default_url_options[:host]
+  <%- unless omit_comments? -%>
+  # Or follow config/environments:
+  #   self.base_url = ActionDispatch::Http::URL.url_for(Rails.application.routes.default_url_options)
+  <%- end -%>
+  self.base_url = ENV.fetch('BASE_URL', 'http://localhost:3000')
   self.endpoint_namespace = '<%= api_namespace %>'
   <%- unless omit_comments? -%>
 
-  # Defaults every Resource inherits. Uncomment to change them API-wide, or set
-  # them on individual Resources. See https://graphiti.dev/concepts/resources
+  # Defaults every Resource inherits. See https://graphiti.dev/concepts/resources
   <%- resource_setting_groups.each_pair do |group, lines| -%>
 
   # <%= group.to_s.humanize %>

data/lib/generators/graphiti/templates/controller.rb.erb

@@ -56,7 +56,7 @@ class <%= controller_class_name %> < ApplicationController
   def update
     <%= file_name %> = <%= resource_klass %>.find(params)
 
-    if <%= file_name %>.update_attributes
+    if <%= file_name %>.update
       render jsonapi: <%= file_name %>
     else
       render jsonapi_errors: <%= file_name %>

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

@@ -0,0 +1,30 @@
+<%- unless omit_comments? -%>
+# For another language, add a block below or a graphiti.<locale>.yml file.
+<%- end -%>
+en:
+  graphiti:
+    errors:
+<%- unless omit_comments? -%>
+      # Keyed by error code. Edit any value to reword it. Comments name what
+      # raises each code, relative to Graphiti::Errors.
+<%- end -%>
+<%- error_titles.each_pair do |code, title| -%>
+      <%= code %>:
+    <%- unless omit_comments? -%>
+      <%- error_source_lines(code).each do |line| -%>
+        # <%= line %>
+      <%- end -%>
+    <%- end -%>
+        title: <%= title.inspect %>
+    <%- if error_detail(code) -%>
+        detail: <%= error_detail(code).inspect %>
+    <%- end -%>
+<%- end -%>
+<%- unless omit_comments? -%>
+      # format joins the two below: "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/generators/graphiti/templates/resource_writes_spec.rb.erb

@@ -45,7 +45,7 @@ RSpec.describe <%= resource_class %>, type: :resource do
 
     xit 'works (add some attributes and enable this spec)' do
       expect {
-        expect(instance.update_attributes).to eq(true)
+        expect(instance.update).to eq(true)
       }.to change { <%= var %>.reload.updated_at }
       # .and change { <%= var %>.foo }.to('bar') <- example
     end

data/lib/graphiti/adapters/active_record.rb

@@ -246,7 +246,7 @@ module Graphiti
 
           children.each do |child|
             if association_type == :many_to_many &&
-                [:create, :update].include?(Graphiti.context[:namespace]) &&
+                [:create, :update].include?(Graphiti.context[:action]) &&
                 !parent.send(association_name).exists?(child.id) &&
                 child.errors.blank?
               parent.send(association_name) << child

data/lib/graphiti/context_hash.rb

@@ -0,0 +1,21 @@
+module Graphiti
+  # graphiti-api/graphiti#134 recommended reading Graphiti.context[:namespace] from base_scope before current_action existed, so the old key keeps working for one major.
+  class ContextHash < Hash
+    def [](key)
+      super(deprecate_namespace(key))
+    end
+
+    def []=(key, value)
+      super(deprecate_namespace(key), value)
+    end
+
+    private
+
+    def deprecate_namespace(key)
+      return key unless key == :namespace
+
+      Graphiti::DEPRECATOR.deprecation_warning(:"context[:namespace]", "Use #current_action instead", caller_locations(2))
+      :action
+    end
+  end
+end

data/lib/graphiti/debugger.rb

@@ -11,13 +11,13 @@ module Graphiti
     private_constant :CHUNKS
 
     class << self
-      # Pool threads inherit this through the thread-local copy Scope#future_with_context makes, so their chunks reach the right request.
+      # Pool threads inherit this through the fiber storage copy Scope#future_with_context makes, so their chunks reach the right request.
       def chunks
-        Thread.current[CHUNKS] ||= Concurrent::Array.new
+        Fiber[CHUNKS] ||= Concurrent::Array.new
       end
 
       def chunks=(value)
-        Thread.current[CHUNKS] = value
+        Fiber[CHUNKS] = value
       end
 
       def on_data(name, start, stop, id, payload)

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

@@ -1,6 +1,8 @@
 module Graphiti
   module ErrorSerializers
     class InvalidRequest
+      include TranslatedTitle
+
       STATUS = 400
 
       attr_reader :source
@@ -48,7 +50,7 @@ module Graphiti
         "bad_request"
       end
 
-      def title
+      def default_title
         "Request Error"
       end
 

data/lib/graphiti/error_serializers/translated_title.rb

@@ -0,0 +1,13 @@
+module Graphiti
+  module ErrorSerializers
+    module TranslatedTitle
+      private
+
+      def title
+        return default_title unless defined?(::I18n)
+
+        ::I18n.t :title, scope: [:graphiti, :errors, code], default: default_title
+      end
+    end
+  end
+end

data/lib/graphiti/error_serializers/validation.rb

@@ -3,6 +3,8 @@ module Graphiti
     # Walks into related objects so nested writes report against the record
     # that actually failed.
     class Validation
+      include TranslatedTitle
+
       attr_reader :object
 
       def initialize(object, relationship_payloads = {}, relationship_meta = {})
@@ -13,14 +15,14 @@ module Graphiti
 
       def attribute_errors
         [].tap do |errors|
-          each_error do |attribute, message, code|
+          each_error do |attribute, message, validation_code|
             errors << {
-              code: "unprocessable_entity",
+              code: code,
               status: "422",
-              title: "Validation Error",
+              title: title,
               detail: detail_for(attribute, message),
               source: {pointer: pointer_for(object, attribute)},
-              meta: meta_for(attribute, message, code, @relationship_meta)
+              meta: meta_for(attribute, message, validation_code, @relationship_meta)
             }
           end
         end
@@ -34,6 +36,14 @@ module Graphiti
 
       private
 
+      def code
+        "unprocessable_entity"
+      end
+
+      def default_title
+        "Validation Error"
+      end
+
       def each_error
         object.errors.messages.each_pair do |attribute, messages|
           details = object.errors.details.find { |k, _| k == attribute }[1]

data/lib/graphiti/query.rb

@@ -26,6 +26,7 @@ module Graphiti
       @parents = parents
       @action = parse_action(action)
       @entity_map = Concurrent::Map.new if parents.empty?
+      @association_owners = Concurrent::Map.new if parents.empty?
     end
 
     def association?
@@ -39,6 +40,12 @@ module Graphiti
       @entity_map
     end
 
+    def association_owners
+      return root.association_owners unless root == self
+
+      @association_owners
+    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
@@ -421,7 +428,7 @@ module Graphiti
     end
 
     def parse_action(action)
-      action ||= @params.fetch(:action, Graphiti.context[:namespace]).try(:to_sym)
+      action ||= @params.fetch(:action, Graphiti.context[:action]).try(:to_sym)
       case action
       when :index
         :all

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
@@ -67,7 +77,7 @@ module Graphiti
       end
 
       def register_mime_type
-        Mime::Type.register(MEDIA_TYPE, :jsonapi)
+        Mime::Type.register(MEDIA_TYPE, :jsonapi) if Mime[:jsonapi].nil?
       end
 
       def register_parameter_parser

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: []