graphiti 2.0.0.beta.12 → 2.0.0.beta.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e73d0272cfabe57d3eb0cbc82ad7199dea624afead6856ca72c1107857fa144
-  data.tar.gz: 795ddb1e77c8f61d2e74c66c333ccc4acd5c37ccb6aa3b4c7cb816f52dfe1b71
+  metadata.gz: 2963ad9851cf238b3885921c2b4858bf3b7aefe1fad5726a588c966da8cd0ada
+  data.tar.gz: 6486ac49fff4aa22faaa46cc2aef5439a015943748fd323288c8f90f596fbf9a
 SHA512:
-  metadata.gz: f5ff1c0630702209372d0512afd16d29c87d6f561c551e08a5080bd25efa8b3bae465d33729129289a3ade41db781b779bffd753b55f6cf7cf02389662fa835e
-  data.tar.gz: '0785ff7bd32570ef7bf588c7287b4704d7f9daf50bafb47f0739f02b054086a297cef4427364f818b5ab540a72935447bead5898957f597a400a40b435f4a81f'
+  metadata.gz: b25b468d3ddf0efc6aa513940ae06c2cc30150e7d4a743bd5ba1d4a56a768f3a7452780b515bbd68610ab51bdd979d577f7644d83a0fa724e975a45a547e1bef
+  data.tar.gz: 02a6b4f82e8e7c2d9582c8765d49ef07901e001ea942846d3b70f79ea25c7e83d4d032c5644404420c075e0565eb946cfb1d54356ed319aefb2841e644bb0944

data/CHANGELOG.md

@@ -1,5 +1,29 @@
 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)
 
 

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/install_generator.rb

@@ -28,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
 
@@ -60,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
 
@@ -83,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

@@ -8,6 +8,28 @@ module Graphiti
       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"))
@@ -19,6 +41,40 @@ module Graphiti
       @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

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

@@ -1,19 +1,27 @@
 <%- 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".
+      # 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:

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/invalid_request.rb

@@ -1,6 +1,8 @@
 module Graphiti
   module ErrorSerializers
     class InvalidRequest
+      include TranslatedTitle
+
       STATUS = 400
 
       attr_reader :source
@@ -48,12 +50,6 @@ module Graphiti
         "bad_request"
       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/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/railtie.rb

@@ -77,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/request_validators/update_validator.rb

@@ -28,7 +28,7 @@ module Graphiti
       end
 
       def payload_matches_endpoint?
-        unless @params.dig(:data, :id) == @params.dig(:filter, :id)
+        unless @params.dig(:data, :id).to_s == @params.dig(:filter, :id).to_s
           attribute_mismatch([:data, :id])
         end
 

data/lib/graphiti/resource.rb

@@ -37,8 +37,8 @@ module Graphiti
       end
     end
 
-    def with_context(object, namespace = nil)
-      Graphiti.with_context(object, namespace) do
+    def with_context(object, action = nil)
+      Graphiti.with_context(object, action) do
         yield
       end
     end
@@ -55,7 +55,7 @@ module Graphiti
     # is called, not a fixed list. Persistence overrides it with :create/:update
     # while saving, and :show while resolving sideloads afterwards.
     def self.current_action
-      Graphiti.context[:namespace]
+      Graphiti.context[:action]
     end
 
     def current_action

data/lib/graphiti/resource_proxy.rb

@@ -159,7 +159,7 @@ module Graphiti
       params = normalized_params_copy(params)
       add_endpoint_filter(params, action)
       validator = ::Graphiti::RequestValidator.new(@resource, params, action)
-      validator.validate!
+      with_context_action(action) { validator.validate! }
 
       if @assigned_model && same_write_payload?(validator.deserialized_payload)
         return @assigned_model
@@ -174,32 +174,36 @@ module Graphiti
       )
     end
 
+    # TODO: remove this. Only used for persisting many-to-many with AR
+    # (see activerecord adapter)
+    def with_context_action(action)
+      original = Graphiti.context[:action]
+      Graphiti.context[:action] = action
+      yield
+    ensure
+      Graphiti.context[:action] = original
+    end
+
     def save(action: :create)
-      # TODO: remove this. Only used for persisting many-to-many with AR
-      # (see activerecord adapter)
-      original = Graphiti.context[:namespace]
-      begin
-        Graphiti.context[:namespace] = action
+      validator = with_context_action(action) do
         # An assigned model can only come from #assign_attributes, which
         # validated the payload it stored - re-validating here would run the
         # writable guards (and their guard_model lookups) a redundant time.
         unless @assigned_model
           ::Graphiti::RequestValidator.new(@resource, @payload.params, action).validate!
         end
-        validator = persist {
+        persist {
           @resource.persist_with_relationships \
             @payload.meta(action: action),
             @payload.attributes,
             @payload.relationships,
             assigned_model: @assigned_model
         }
-      ensure
-        Graphiti.context[:namespace] = original
       end
       @data, success = validator.to_a
 
       if success
-        # If the context namespace is `update` or `create`, certain
+        # If the context action is `update` or `create`, certain
         # adapters will cause N+1 validation calls, so lets explicitly
         # switch to a lookup context.
         Graphiti.with_context(Graphiti.context[:object], :show) do

data/lib/graphiti/scope.rb

@@ -39,18 +39,17 @@ module Graphiti
       !Graphiti.config.concurrency || on_pool_thread?
     end
 
-    # TODO: move to Fiber[] once the floor is Ruby 3.2
     def self.on_pool_thread?
-      Thread.current[POOL_THREAD] == true
+      Fiber[POOL_THREAD] == true
     end
 
     # Restores rather than clears because :caller_runs may have run the task on a request thread.
     def self.marking_pool_thread
-      previous = Thread.current[POOL_THREAD]
-      Thread.current[POOL_THREAD] = true
+      previous = Fiber[POOL_THREAD]
+      Fiber[POOL_THREAD] = true
       yield
     ensure
-      Thread.current[POOL_THREAD] = previous
+      Fiber[POOL_THREAD] = previous
     end
 
     def initialize(object, resource, query, opts = {})

data/lib/graphiti/sideload.rb

@@ -61,6 +61,27 @@ module Graphiti
       self.scope_proc = blk
     end
 
+    ASSIGNING_QUERY = :__graphiti_assigning_query
+    private_constant :ASSIGNING_QUERY
+
+    def self.assigning_node(query)
+      return yield if query.nil?
+
+      previous = Fiber[ASSIGNING_QUERY]
+      Fiber[ASSIGNING_QUERY] = query
+      yield
+    ensure
+      Fiber[ASSIGNING_QUERY] = previous unless query.nil?
+    end
+
+    def self.current_assigning_query
+      Fiber[ASSIGNING_QUERY]
+    end
+
+    def self.assigned?(query, record, association_name)
+      query.association_owners.key?([record.object_id, association_name])
+    end
+
     def self.assign(&blk)
       self.assign_proc = blk
     end
@@ -365,7 +386,7 @@ module Graphiti
 
       if self.class.scope_proc
         build_sideload_scope(parents, query, graph_parent).resolve do |sideload_results|
-          fire_assign(parents, sideload_results)
+          fire_assign(parents, sideload_results, query)
         end
       else
         sync_load(parents, query, graph_parent, &proxy_block)
@@ -378,7 +399,7 @@ module Graphiti
 
       if self.class.scope_proc
         build_sideload_scope(parents, query, graph_parent).future_resolve do |sideload_results|
-          fire_assign(parents, sideload_results)
+          fire_assign(parents, sideload_results, query)
         end
       else
         future_load(parents, query, graph_parent, &proxy_block)
@@ -413,10 +434,14 @@ module Graphiti
     end
 
     def associate_all(parent, children)
+      return unless claim_association(parent)
+
       parent_resource.associate_all(parent, children, association_name, type)
     end
 
     def associate(parent, child)
+      return unless claim_association(parent)
+
       parent_resource.associate(parent, child, association_name, type)
     end
 
@@ -506,7 +531,7 @@ module Graphiti
         opts[:sideload_parent_length] = parents.length
         opts[:query] = query
         opts[:after_resolve] = ->(results) {
-          fire_assign(parents, results)
+          fire_assign(parents, results, query)
         }
       end
     end
@@ -519,16 +544,28 @@ module Graphiti
       end
     end
 
-    def fire_assign(parents, children)
-      with_error_handling Errors::SideloadAssignError do
-        if self.class.assign_proc
-          instance_exec(parents, children, &self.class.assign_proc)
-        else
-          assign(parents, children)
+    def fire_assign(parents, children, query = nil)
+      self.class.assigning_node(query) do
+        with_error_handling Errors::SideloadAssignError do
+          if self.class.assign_proc
+            instance_exec(parents, children, &self.class.assign_proc)
+          else
+            assign(parents, children)
+          end
         end
       end
     end
 
+    # A record can be shared by two nodes of the include tree, and a node that narrows
+    # differently returns different rows, so the first node to populate an association owns it.
+    def claim_association(parent)
+      query = self.class.current_assigning_query
+      return true if query.nil?
+
+      key = [parent.object_id, association_name]
+      query.association_owners.compute_if_absent(key) { query.hash } == query.hash
+    end
+
     def with_error_handling(error_class)
       begin
         result = yield

data/lib/graphiti/spec_helpers/matchers.rb

@@ -59,6 +59,7 @@ module Graphiti
 
       class RelationMatcher < BaseMatcher
         GRAPHITI_OPTS = %i[primary_key foreign_key resource readable writable link single].freeze
+        SIDELOAD_METHODS = {resource: :resource_class, readable: :readable?, writable: :writable?, single: :single?}.freeze
         GRAPHITI_CONFIG_KEY = :sideloads
         EXPECTED_ACTION = ""
 
@@ -73,7 +74,7 @@ module Graphiti
         attr_reader :target, :opts, :resource
 
         def assert_opt(opt)
-          asserted_opt = (opt == :resource) ? :resource_class : opt
+          asserted_opt = SIDELOAD_METHODS.fetch(opt, opt)
           return true if config.send(asserted_opt) == opts[opt]
 
           @opt_failures << opt_failure_message(opt, opts[opt], config.send(asserted_opt))

data/lib/graphiti/util/serializer_relationships.rb

@@ -71,7 +71,7 @@ module Graphiti
           # not predict, so the loaded records win. Only the un-included case
           # is worth short-circuiting.
           if sideload_ref.resource_ids_from_foreign_key? &&
-              !self_ref.send(:included_anywhere?, @proxy.query.include_hash, sideload_ref.name)
+              !::Graphiti::Sideload.assigned?(@proxy.query, @object, sideload_ref.association_name)
             linkage always: sideload_ref.render_resource_ids? do
               foreign_key = begin
                 @object.public_send(sideload_ref.foreign_key)
@@ -104,15 +104,6 @@ module Graphiti
         end
       end
 
-      # A relationship nested under another one is still loaded and can still
-      # be narrowed by a deep filter, so the foreign key is not a safe
-      # stand-in for what the request actually returns.
-      def included_anywhere?(include_hash, name)
-        include_hash.any? do |key, nested|
-          key == name || included_anywhere?(nested, name)
-        end
-      end
-
       def data_proc
         sideload_ref = @sideload
         resource_class_ref = @resource_class

data/lib/graphiti/util/transaction_hooks_recorder.rb

@@ -58,11 +58,11 @@ module Graphiti
         private
 
         def _hooks
-          Thread.current[:_graphiti_hooks]
+          Fiber[:_graphiti_hooks]
         end
 
         def reset_hooks
-          Thread.current[:_graphiti_hooks] = {
+          Fiber[:_graphiti_hooks] = {
             after_graph_persist: [],
             before_commit: [],
             after_commit: []

data/lib/graphiti/version.rb

@@ -1,3 +1,3 @@
 module Graphiti
-  VERSION = "2.0.0.beta.12"
+  VERSION = "2.0.0.beta.13"
 end

data/lib/graphiti.rb

@@ -51,18 +51,20 @@ module Graphiti
 
   # @api private
   def self.context
-    Thread.current[:context] ||= {}
+    Fiber[:context] ||= ContextHash.new
   end
 
   # @api private
   def self.context=(val)
-    Thread.current[:context] = val
+    Fiber[:context] = ContextHash.new.tap do |hash|
+      val.each { |key, value| hash[key] = value }
+    end
   end
 
   # @api private
-  def self.with_context(obj, namespace = nil)
+  def self.with_context(obj, action = nil)
     prior = context
-    self.context = {object: obj, namespace: namespace}
+    self.context = {object: obj, action: action}
     yield
   ensure
     self.context = prior
@@ -169,6 +171,7 @@ require "graphiti/version"
 require "graphiti/jsonapi_serializable_ext"
 require "graphiti/configuration"
 require "graphiti/context"
+require "graphiti/context_hash"
 require "graphiti/errors"
 require "graphiti/types"
 require "graphiti/audit"
@@ -239,6 +242,7 @@ require "graphiti/query"
 require "graphiti/debugger"
 require "graphiti/util/cache_debug"
 require "graphiti/util/uri_decoder"
+require "graphiti/error_serializers/translated_title"
 require "graphiti/error_serializers/validation"
 require "graphiti/error_serializers/invalid_request"
 require "graphiti/error_serializers/conflict_request"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graphiti
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta.12
+  version: 2.0.0.beta.13
 platform: ruby
 authors:
 - Lee Richmond
@@ -318,12 +318,14 @@ files:
 - lib/graphiti/cli.rb
 - lib/graphiti/configuration.rb
 - lib/graphiti/context.rb
+- lib/graphiti/context_hash.rb
 - lib/graphiti/debugger.rb
 - lib/graphiti/delegates/pagination.rb
 - lib/graphiti/deserializer.rb
 - lib/graphiti/error_serializers/conflict_request.rb
 - lib/graphiti/error_serializers/deprecated_constants.rb
 - lib/graphiti/error_serializers/invalid_request.rb
+- lib/graphiti/error_serializers/translated_title.rb
 - lib/graphiti/error_serializers/validation.rb
 - lib/graphiti/errors.rb
 - lib/graphiti/extensions/boolean_attribute.rb