graphiti 1.13.4 → 2.0.0.beta.1

data/lib/graphiti/resource.rb

@@ -123,9 +123,18 @@ module Graphiti
       adapter.disassociate(parent, child, association_name, type)
     end
 
-    def persist_with_relationships(meta, attributes, relationships, caller_model = nil, foreign_key = nil)
+    # TODO: make foreign_key a keyword once the satellite gems are rolled in - they call these positionally
+    def assign_with_relationships(meta, attributes, relationships, caller_model = nil, foreign_key = nil, model_instance: nil)
       persistence = Graphiti::Util::Persistence \
-        .new(self, meta, attributes, relationships, caller_model, foreign_key)
+        .new(self, meta, attributes, relationships, caller_model, foreign_key,
+          assigned_model: model_instance)
+      persistence.assign
+    end
+
+    def persist_with_relationships(meta, attributes, relationships, caller_model = nil, foreign_key = nil, assigned_model: nil)
+      persistence = Graphiti::Util::Persistence \
+        .new(self, meta, attributes, relationships, caller_model, foreign_key,
+          assigned_model: assigned_model)
       persistence.run
     end
 

data/lib/graphiti/resource_proxy.rb

@@ -11,6 +11,7 @@ module Graphiti
       payload: nil,
       single: false,
       raise_on_missing: false,
+      assign_action: nil,
       cache: nil,
       cache_expires_in: nil,
       cache_tag: nil
@@ -22,6 +23,7 @@ module Graphiti
       @payload = payload
       @single = single
       @raise_on_missing = raise_on_missing
+      @assign_action = assign_action
       @cache = cache
       @cache_expires_in = cache_expires_in
       @cache_tag = cache_tag
@@ -80,14 +82,11 @@ module Graphiti
       Renderer.new(self, options).as_graphql
     end
 
-    # Records supplied directly, no scope resolution
-    def data=(models)
-      @data = models
-      [@data].flatten.compact.each { |record| @resource.decorate_record(record) }
-    end
-
     def data
-      @data ||= begin
+      return @data unless @data.nil?
+      return assign_attributes(@payload.params) if @assign_action
+
+      @data = begin
         records = @scope.resolve
         raise Graphiti::Errors::RecordNotFound if records.empty? && raise_on_missing?
 
@@ -95,6 +94,7 @@ module Graphiti
         records
       end
     end
+
     alias_method :to_a, :data
     alias_method :resolve_data, :data
 
@@ -137,18 +137,56 @@ module Graphiti
       @pagination ||= Delegates::Pagination.new(self)
     end
 
+    # Apply request params to the underlying model without saving it,
+    # Rails-style: the params are always passed explicitly, in the same
+    # request-params shape find/build accept. They are validated,
+    # deserialized, and become the payload #save will persist.
+    #
+    # Idempotent per params - calling again with params that normalize to
+    # the same payload is a no-op, so the attributes callbacks fire once.
+    # Different params re-assign onto the same model instance.
+    #
+    # Note the attributes callbacks fire here, outside any transaction
+    # opened during #save - the persistence hooks wrap only the save phase,
+    # receiving this assigned model.
+    def assign_attributes(params)
+      action = @assign_action || :update
+      params = normalized_params_copy(params)
+      add_endpoint_filter(params, action)
+      validator = ::Graphiti::RequestValidator.new(@resource, params, action)
+      validator.validate!
+
+      if @assigned_model && same_write_payload?(validator.deserialized_payload)
+        return @assigned_model
+      end
+
+      @payload = validator.deserialized_payload
+      @assigned_model = @data = @resource.assign_with_relationships(
+        @payload.meta(action: action),
+        @payload.attributes,
+        @payload.relationships,
+        model_instance: @assigned_model || (data if action == :update)
+      )
+    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
-        ::Graphiti::RequestValidator.new(@resource, @payload.params, action).validate!
+        # 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 {
           @resource.persist_with_relationships \
             @payload.meta(action: action),
             @payload.attributes,
-            @payload.relationships
+            @payload.relationships,
+            assigned_model: @assigned_model
         }
       ensure
         Graphiti.context[:namespace] = original
@@ -185,12 +223,16 @@ module Graphiti
       success
     end
 
-    def update
+    # Rails-style: pass params to assign and save in one call, or call with
+    # no arguments to save a payload assigned earlier (via find or
+    # #assign_attributes).
+    def update(params = nil)
+      assign_attributes(params) if params
       resolve_data
       save(action: :update)
     end
 
-    alias update_attributes update # standard:disable Style/Alias
+    alias_method :update_attributes, :update
 
     def include_hash
       @include_hash ||= begin
@@ -247,6 +289,39 @@ module Graphiti
 
     private
 
+    # Validation typecasts values and injects ids into the params it is
+    # given - work on a deep copy so the caller's hash stays untouched.
+    def normalized_params_copy(params)
+      if params.respond_to?(:to_unsafe_h)
+        params.to_unsafe_h.deep_symbolize_keys
+      else
+        ::Graphiti::Util::Hash.deep_dup(params)
+      end
+    end
+
+    # UpdateValidator enforces that data.id matches the endpoint's filter id.
+    # Params that came through find already carry that filter; params passed
+    # directly to #assign_attributes usually don't, so merge in the id this
+    # proxy was found with. A payload whose data.id names a different record
+    # still fails validation with ConflictRequest. Mutates the copy made by
+    # #normalized_params_copy, never caller state.
+    def add_endpoint_filter(params, action)
+      return unless action == :update
+
+      endpoint_id = @query.filters[:id]
+      return if endpoint_id.nil? || params[:filter].try(:[], :id)
+
+      params[:filter] ||= {}
+      params[:filter][:id] = endpoint_id
+    end
+
+    # Compare only the write payload (data + included) - a repeat call whose
+    # params differ in read-side keys like sort or page is still a no-op.
+    def same_write_payload?(deserialized_payload)
+      deserialized_payload.params.values_at(:data, :included) ==
+        @payload.params.values_at(:data, :included)
+    end
+
     def persist
       transaction_response = @resource.transaction do
         ::Graphiti::Util::TransactionHooksRecorder.record do

data/lib/graphiti/runner.rb

@@ -3,12 +3,12 @@ module Graphiti
     attr_reader :params
     attr_reader :deserialized_payload
 
+    # TODO: make query and action keywords once the satellite gems are rolled in - they instantiate Runner positionally
     def initialize(resource_class, params, query = nil, action = nil)
       @resource_class = resource_class
       @params = params
       @query = query
       @action = action
-
       validator = RequestValidator.new(jsonapi_resource, params, action)
       validator.validate!
 
@@ -77,6 +77,7 @@ module Graphiti
         payload: deserialized_payload,
         single: opts[:single],
         raise_on_missing: opts[:raise_on_missing],
+        assign_action: opts[:assign_action],
         cache: opts[:cache],
         cache_expires_in: opts[:cache_expires_in],
         cache_tag: opts[:cache_tag]

data/lib/graphiti/scope.rb

@@ -31,28 +31,6 @@ module Graphiti
       end
     end
 
-    POOL_THREAD = :__graphiti_pool_thread
-    private_constant :POOL_THREAD
-
-    # A pool thread that waits on the pool deadlocks, since the task it waits for cannot start until the waiting thread frees its slot.
-    def self.resolve_synchronously?
-      !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
-    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
-      yield
-    ensure
-      Thread.current[POOL_THREAD] = previous
-    end
-
     def initialize(object, resource, query, opts = {})
       @object = object
       @resource = resource
@@ -70,25 +48,29 @@ module Graphiti
       # Thread/Fiber storage snapshots, and Rails executor wrappers on every
       # request purely to drive a thread pool that is intentionally synchronous.
       # See https://github.com/graphiti-api/graphiti/issues/505
-      if self.class.resolve_synchronously?
-        sync_resolve(&blk)
-      else
-        future_resolve(&blk).value!
-      end
+      return sync_resolve(&blk) unless Graphiti.config.concurrency
+
+      future_resolve.value!
     end
 
     def resolve_sideloads(results)
-      if self.class.resolve_synchronously?
-        sync_resolve_sideloads(results)
-      else
-        future_resolve_sideloads(results).value!
-      end
+      return sync_resolve_sideloads(results) unless Graphiti.config.concurrency
+
+      future_resolve_sideloads(results).value!
     end
 
-    def future_resolve(&blk)
+    def future_resolve
       return Concurrent::Promises.fulfilled_future([], self.class.global_thread_pool_executor) if @query.zero_results?
 
-      resolved = resolve_primary_data(&blk)
+      resolved = broadcast_data { |payload|
+        @object = @resource.before_resolve(@object, @query)
+        payload[:results] = @resource.resolve(@object)
+        payload[:results]
+      }
+      resolved.compact!
+      assign_serializer(resolved)
+      yield resolved if block_given?
+      @opts[:after_resolve]&.call(resolved)
       sideloaded = @query.parents.any?
       close_adapter = Graphiti.config.concurrency && sideloaded
       if close_adapter
@@ -140,29 +122,12 @@ module Graphiti
 
     private
 
-    def sync_resolve(&blk)
+    # Synchronous counterpart to #future_resolve, used when concurrency is off.
+    # Resolves the resource and its sideloads inline without any promise
+    # machinery. See #resolve.
+    def sync_resolve
       return [] if @query.zero_results?
 
-      resolved = resolve_primary_data(&blk)
-      sync_resolve_sideloads(resolved)
-      resolved
-    end
-
-    def sync_resolve_sideloads(results)
-      return if results == []
-
-      each_applicable_sideload do |sideload, sideload_query|
-        Graphiti.config.before_sideload&.call(Graphiti.context)
-        sideload.resolve(results, sideload_query, @resource)
-      end
-
-      # resolve_sideloads is public, and without this it would return @query.sideloads itself, 
-      # where a delete would silently drop that sideload from the cache key.
-      nil
-    end
-
-    # Runs inline on the calling thread in both the sync and future paths.
-    def resolve_primary_data
       resolved = broadcast_data { |payload|
         @object = @resource.before_resolve(@object, @query)
         payload[:results] = @resource.resolve(@object)
@@ -172,28 +137,40 @@ module Graphiti
       assign_serializer(resolved)
       yield resolved if block_given?
       @opts[:after_resolve]&.call(resolved)
+      sync_resolve_sideloads(resolved) unless @query.sideloads.empty?
       resolved
     end
 
-    def each_applicable_sideload
-      @query.sideloads.each_pair do |name, sideload_query|
+    # Synchronous counterpart to #future_resolve_sideloads, used when
+    # concurrency is off. Resolves each sideload inline. See #resolve_sideloads.
+    def sync_resolve_sideloads(results)
+      return if results == []
+
+      @query.sideloads.each_pair do |name, q|
         sideload = @resource.class.sideload(name)
         next if sideload.nil? || sideload.shared_remote?
 
-        yield sideload, sideload_query
+        Graphiti.config.before_sideload&.call(Graphiti.context)
+        sideload.resolve(results, q, @resource)
       end
+
+      # Match pre-1.8 semantics: the non-concurrent resolve_sideloads returned
+      # nil (not the sideloads Hash). Callers don't rely on the return value.
+      nil
     end
 
     def future_resolve_sideloads(results)
       return Concurrent::Promises.fulfilled_future(nil, self.class.global_thread_pool_executor) if results == []
 
-      sideload_promises = []
-      each_applicable_sideload do |sideload, sideload_query|
-        promise = future_with_context(results, sideload_query, @resource) do |parent_results, future_query, parent_resource|
+      sideload_promises = @query.sideloads.filter_map do |name, q|
+        sideload = @resource.class.sideload(name)
+        next if sideload.nil? || sideload.shared_remote?
+
+        p = future_with_context(results, q, @resource) do |parent_results, sideload_query, parent_resource|
           Graphiti.config.before_sideload&.call(Graphiti.context)
-          sideload.future_resolve(parent_results, future_query, parent_resource)
+          sideload.future_resolve(parent_results, sideload_query, parent_resource)
         end
-        sideload_promises << promise.flat
+        p.flat
       end
 
       Concurrent::Promises.zip_futures_on(self.class.global_thread_pool_executor, *sideload_promises)
@@ -204,10 +181,7 @@ module Graphiti
     end
 
     def future_with_context(*args)
-      # TODO: we only need Fiber.storage after Ruby 3.2 is the floor
       thread_storage = Thread.current.keys.each_with_object({}) do |key, memo|
-        next if key == POOL_THREAD
-
         memo[key] = Thread.current[key]
       end
       fiber_storage =
@@ -220,13 +194,11 @@ module Graphiti
       Concurrent::Promises.future_on(
         self.class.global_thread_pool_executor, Thread.current.object_id, thread_storage, fiber_storage, *args
       ) do |thread_id, thread_storage, fiber_storage, *args|
-        self.class.marking_pool_thread do
-          wrap_in_rails_executor do
-            with_thread_locals(thread_storage) do
-              with_fiber_locals(fiber_storage) do
-                Graphiti.broadcast(:global_thread_pool_task_run, self.class.global_thread_pool_stats) do
-                  yield(*args)
-                end
+        wrap_in_rails_executor do
+          with_thread_locals(thread_storage) do
+            with_fiber_locals(fiber_storage) do
+              Graphiti.broadcast(:global_thread_pool_task_run, self.class.global_thread_pool_stats) do
+                yield(*args)
               end
             end
           end

data/lib/graphiti/scoping/filter.rb

@@ -209,9 +209,7 @@ module Graphiti
     end
 
     def parse_string_null(filter, value)
-      return value unless filter[:allow_nil]
-      return value.map { |item| item == "null" ? nil : item } if value.is_a?(Array)
-      return if value == "null"
+      return if value == "null" && filter[:allow_nil]
 
       value
     end

data/lib/graphiti/serializer.rb

@@ -103,6 +103,7 @@ module Graphiti
     def strip_relationships?
       return false unless Graphiti.config.links_on_demand
       params = Graphiti.context[:object]&.params || {}
+
       [false, nil, "false"].include?(params[:links])
     end
   end

data/lib/graphiti/sideload/polymorphic_belongs_to.rb

@@ -108,42 +108,40 @@ class Graphiti::Sideload::PolymorphicBelongsTo < Graphiti::Sideload::BelongsTo
   end
 
   def resolve(parents, query, graph_parent)
-    if ::Graphiti::Scope.resolve_synchronously?
-      sync_resolve(parents, query, graph_parent)
-    else
-      future_resolve(parents, query, graph_parent).value!
-    end
-  end
+    return future_resolve(parents, query, graph_parent).value! if Graphiti.config.concurrency
 
-  def future_resolve(parents, query, graph_parent)
-    promises = []
-    each_resolvable_group(parents, query) do |child, group, child_query|
-      promises << child.future_resolve(group, child_query, graph_parent)
-    end
-    Concurrent::Promises.zip(*promises)
-  end
-
-  private
+    parents.group_by(&grouper.field_name).each_pair do |group_name, group|
+      next if group_name.nil? || grouper.ignore?(group_name)
 
-  def sync_resolve(parents, query, graph_parent)
-    each_resolvable_group(parents, query) do |child, group, child_query|
-      child.resolve(group, child_query, graph_parent)
+      match = ->(c) { c.group_name == group_name.to_sym }
+      if (sideload = children.values.find(&match))
+        duped = remove_invalid_sideloads(sideload.resource, query)
+        sideload.resolve(group, duped, graph_parent)
+      else
+        err = ::Graphiti::Errors::PolymorphicSideloadChildNotFound
+        raise err.new(self, group_name)
+      end
     end
   end
 
-  def each_resolvable_group(parents, query)
-    parents.group_by(&grouper.field_name).each_pair do |group_name, group|
+  def future_resolve(parents, query, graph_parent)
+    promises = parents.group_by(&grouper.field_name).filter_map do |(group_name, group)|
       next if group_name.nil? || grouper.ignore?(group_name)
 
-      child = children.values.find { |candidate| candidate.group_name == group_name.to_sym }
-      unless child
-        raise ::Graphiti::Errors::PolymorphicSideloadChildNotFound.new(self, group_name)
+      match = ->(c) { c.group_name == group_name.to_sym }
+      if (sideload = children.values.find(&match))
+        duped = remove_invalid_sideloads(sideload.resource, query)
+        sideload.future_resolve(group, duped, graph_parent)
+      else
+        err = ::Graphiti::Errors::PolymorphicSideloadChildNotFound
+        raise err.new(self, group_name)
       end
-
-      yield child, group, remove_invalid_sideloads(child.resource, query)
     end
+    Concurrent::Promises.zip(*promises)
   end
 
+  private
+
   # We may be requesting a relationship that some subclasses support,
   # but not others. Remove anything we don't support.
   # TODO: spec to ensure this dupe logic doesn't mutate the original

data/lib/graphiti/sideload.rb

@@ -240,11 +240,9 @@ module Graphiti
     end
 
     def load(parents, query, graph_parent)
-      if Scope.resolve_synchronously?
-        build_resource_proxy(parents, query, graph_parent).to_a
-      else
-        future_load(parents, query, graph_parent).value!
-      end
+      return build_resource_proxy(parents, query, graph_parent).to_a unless Graphiti.config.concurrency
+
+      future_load(parents, query, graph_parent).value!
     end
 
     # Override in subclass
@@ -294,19 +292,48 @@ module Graphiti
       children.replace(associated) if track_associated
     end
 
+    # Synchronous counterpart to #future_resolve, used when concurrency is off.
+    # Mirrors #future_resolve but resolves inline via the synchronous
+    # Scope#resolve / #load paths (no promises). See Scope#sync_resolve_sideloads.
     def resolve(parents, query, graph_parent)
-      if Scope.resolve_synchronously?
-        sync_resolve(parents, query, graph_parent)
+      return future_resolve(parents, query, graph_parent).value! if Graphiti.config.concurrency
+
+      if single? && parents.length > 1
+        raise Errors::SingularSideload.new(self, parents.length)
+      end
+
+      if self.class.scope_proc
+        sideload_scope = fire_scope(parents)
+        sideload_scope = Scope.new sideload_scope,
+          resource,
+          query,
+          parent: graph_parent,
+          sideload: self,
+          sideload_parent_length: parents.length,
+          default_paginate: false
+        sideload_scope.resolve do |sideload_results|
+          fire_assign(parents, sideload_results)
+        end
       else
-        future_resolve(parents, query, graph_parent).value!
+        load(parents, query, graph_parent)
       end
     end
 
     def future_resolve(parents, query, graph_parent)
-      assert_singular!(parents)
+      if single? && parents.length > 1
+        raise Errors::SingularSideload.new(self, parents.length)
+      end
 
       if self.class.scope_proc
-        build_sideload_scope(parents, query, graph_parent).future_resolve do |sideload_results|
+        sideload_scope = fire_scope(parents)
+        sideload_scope = Scope.new sideload_scope,
+          resource,
+          query,
+          parent: graph_parent,
+          sideload: self,
+          sideload_parent_length: parents.length,
+          default_paginate: false
+        sideload_scope.future_resolve do |sideload_results|
           fire_assign(parents, sideload_results)
         end
       else
@@ -374,34 +401,6 @@ module Graphiti
 
     private
 
-    def sync_resolve(parents, query, graph_parent)
-      assert_singular!(parents)
-
-      if self.class.scope_proc
-        build_sideload_scope(parents, query, graph_parent).resolve do |sideload_results|
-          fire_assign(parents, sideload_results)
-        end
-      else
-        load(parents, query, graph_parent)
-      end
-    end
-
-    def assert_singular!(parents)
-      if single? && parents.length > 1
-        raise Errors::SingularSideload.new(self, parents.length)
-      end
-    end
-
-    def build_sideload_scope(parents, query, graph_parent)
-      Scope.new fire_scope(parents),
-        resource,
-        query,
-        parent: graph_parent,
-        sideload: self,
-        sideload_parent_length: parents.length,
-        default_paginate: false
-    end
-
     def future_load(parents, query, graph_parent)
       proxy = build_resource_proxy(parents, query, graph_parent)
       proxy.respond_to?(:future_resolve_data) ? proxy.future_resolve_data : Concurrent::Promises.fulfilled_future(proxy)

data/lib/graphiti/types.rb

@@ -82,10 +82,6 @@ module Graphiti
       Dry::Types["params.hash"][input]
     }
 
-    ParamArray = Dry::Types["strict.array"].constructor { |input|
-      input.is_a?(String) ? [input] : input
-    }
-
     REQUIRED_KEYS = [:params, :read, :write, :kind, :description]
 
     def self.map
@@ -197,7 +193,7 @@ module Graphiti
 
           arrays[:"array_of_#{name.to_s.pluralize}"] = {
             canonical_name: name,
-            params: ParamArray.of(map[:params]),
+            params: Dry::Types["strict.array"].of(map[:params]),
             read: Dry::Types["strict.array"].of(map[:read]),
             test: Dry::Types["strict.array"].of(map[:test]),
             write: Dry::Types["strict.array"].of(map[:write]),

data/lib/graphiti/util/hash.rb

@@ -55,8 +55,15 @@ module Graphiti
         else
           {}.tap do |duped|
             hash.each_pair do |key, value|
-              value = deep_dup(value) if value.is_a?(Hash)
-              value = value.dup if value&.respond_to?(:dup) && ![Symbol, Integer].include?(value.class)
+              value = if value.is_a?(Hash)
+                deep_dup(value)
+              elsif value.is_a?(Array)
+                value.map { |element| element.is_a?(Hash) ? deep_dup(element) : element }
+              elsif value&.respond_to?(:dup) && ![Symbol, Integer].include?(value.class)
+                value.dup
+              else
+                value
+              end
               duped[key] = value
             end
           end