graphql 2.5.3 → 2.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d2e4ec1acc9810683bb2628dc5403c74d729742612655f1be275267a89b107b3
-  data.tar.gz: fb092108f803095aea29b325859fc810feaa8e5fdb6c873c431f9824428fbc15
+  metadata.gz: 170be4878ee16ebea26a272dde50923d35e624c87e1154b34de61a10f6a9fae0
+  data.tar.gz: 5ac223538670c8a24c2748e0819cab3b5e0627c14b4a4745559fdedfcd8440fb
 SHA512:
-  metadata.gz: 603e3da13be680884399546074dae65f44635382e13311758e237f7973bbdd96f4a1a46f6b17476af77d88177f5e82f3c76b227633e2e15a9c909365a818f97e
-  data.tar.gz: d631c5a9e1c91fb815d98e1981641405c344b589c6e823ae5609b25fd819a2d5dc9032f366c94a3da69c56a48aa7d8e9ee082cbfa217807e6cbf313d16cbd598
+  metadata.gz: 272a8d48f0ec1d0ad1a79021dc103aede933d34a35829512bf0d46bcbcbc3bafe3b3484cbd38c26ba8193144f3a4024c1c69bd732c9e4cf472307fd15c1d1a33
+  data.tar.gz: b1a66e945b02251b72410c792a91ba5d28cbe82e3eba3891bd3a708382076c2da9e6cf1349c3b688a0f7f87ba06d9bb1b83d06e4c3282e47c0c9724d76cb187b

data/lib/graphql/analysis/query_complexity.rb

@@ -28,14 +28,14 @@ module GraphQL
           end
         when nil
           subject.logger.warn <<~GRAPHQL
-            GraphQL-Ruby's complexity cost system is getting some "breaking fixes" in a future version. See the migration notes at https://graphql-ruby.org/api-docs/#{GraphQL::VERSION}/Schema.html#complexity_cost_cacluation_mode-class_method
+            GraphQL-Ruby's complexity cost system is getting some "breaking fixes" in a future version. See the migration notes at https://graphql-ruby.org/api-doc/#{GraphQL::VERSION}/GraphQL/Schema.html#complexity_cost_calculation_mode_for-class_method
 
             To opt into the future behavior, configure your schema (#{subject.schema.name ? subject.schema.name : subject.schema.ancestors}) with:
 
               complexity_cost_calculation_mode(:future) # or `:legacy`, `:compare`
 
           GRAPHQL
-          max_possible_complexity
+          max_possible_complexity(mode: :legacy)
         else
           raise ArgumentError, "Expected `:future`, `:legacy`, `:compare`, or `nil` from `#{query.schema}.complexity_cost_calculation_mode_for` but got: #{query.schema.complexity_cost_calculation_mode.inspect}"
         end

data/lib/graphql/dataloader/active_record_association_source.rb

@@ -12,6 +12,14 @@ module GraphQL
         @scope = scope
       end
 
+      def self.batch_key_for(association, scope = nil)
+        if scope
+          [association, scope.to_sql]
+        else
+          [association]
+        end
+      end
+
       def load(record)
         if (assoc = record.association(@association)).loaded?
           assoc.target
@@ -41,17 +49,17 @@ module GraphQL
         ::ActiveRecord::Associations::Preloader.new(records: records, associations: @association, available_records: available_records, scope: @scope).call
 
         loaded_associated_records = records.map { |r| r.public_send(@association) }
-        records_by_model = {}
-        loaded_associated_records.each do |record|
-          if record
-            updates = records_by_model[record.class] ||= {}
-            updates[record.id] = record
-          end
-        end
 
         if @scope.nil?
           # Don't cache records loaded via scope because they might have reduced `SELECT`s
           # Could check .select_values here?
+          records_by_model = {}
+          loaded_associated_records.flatten.each do |record|
+            if record
+              updates = records_by_model[record.class] ||= {}
+              updates[record.id] = record
+            end
+          end
           records_by_model.each do |model_class, updates|
             dataloader.with(RECORD_SOURCE_CLASS, model_class).merge(updates)
           end

data/lib/graphql/dataloader/active_record_source.rb

@@ -7,18 +7,39 @@ module GraphQL
       def initialize(model_class, find_by: model_class.primary_key)
         @model_class = model_class
         @find_by = find_by
-        @type_for_column = @model_class.type_for_attribute(@find_by)
+        @find_by_many = find_by.is_a?(Array)
+        if @find_by_many
+          @type_for_column = @find_by.map { |fb| @model_class.type_for_attribute(fb) }
+        else
+          @type_for_column = @model_class.type_for_attribute(@find_by)
+        end
       end
 
-      def load(requested_key)
-        casted_key = @type_for_column.cast(requested_key)
-        super(casted_key)
+      def result_key_for(requested_key)
+        normalize_fetch_key(requested_key)
+      end
+
+      def normalize_fetch_key(requested_key)
+        if @find_by_many
+          requested_key.each_with_index.map do |k, idx|
+            @type_for_column[idx].cast(k)
+          end
+        else
+          @type_for_column.cast(requested_key)
+        end
       end
 
       def fetch(record_ids)
         records = @model_class.where(@find_by => record_ids)
         record_lookup = {}
-        records.each { |r| record_lookup[r.public_send(@find_by)] = r }
+        if @find_by_many
+          records.each do |r|
+            key = @find_by.map { |fb| r.public_send(fb) }
+            record_lookup[key] = r
+          end
+        else
+          records.each { |r| record_lookup[r.public_send(@find_by)] = r }
+        end
         record_ids.map { |id| record_lookup[id] }
       end
     end

data/lib/graphql/dataloader/source.rb

@@ -21,7 +21,7 @@ module GraphQL
       def request(value)
         res_key = result_key_for(value)
         if !@results.key?(res_key)
-          @pending[res_key] ||= value
+          @pending[res_key] ||= normalize_fetch_key(value)
         end
         Dataloader::Request.new(self, value)
       end
@@ -35,12 +35,24 @@ module GraphQL
         value
       end
 
+      # Implement this method if varying values given to {load} (etc) should be consolidated
+      # or normalized before being handed off to your {fetch} implementation.
+      #
+      # This is different than {result_key_for} because _that_ method handles unification inside Dataloader's cache,
+      # but this method changes the value passed into {fetch}.
+      #
+      # @param value [Object] The value passed to {load}, {load_all}, {request}, or {request_all}
+      # @return [Object] The value given to {fetch}
+      def normalize_fetch_key(value)
+        value
+      end
+
       # @return [Dataloader::Request] a pending request for a values from `keys`. Call `.load` on that object to wait for the results.
       def request_all(values)
         values.each do |v|
           res_key = result_key_for(v)
           if !@results.key?(res_key)
-            @pending[res_key] ||= v
+            @pending[res_key] ||= normalize_fetch_key(v)
           end
         end
         Dataloader::RequestAll.new(self, values)
@@ -53,7 +65,7 @@ module GraphQL
         if @results.key?(result_key)
           result_for(result_key)
         else
-          @pending[result_key] ||= value
+          @pending[result_key] ||= normalize_fetch_key(value)
           sync([result_key])
           result_for(result_key)
         end
@@ -68,7 +80,7 @@ module GraphQL
           k = result_key_for(v)
           result_keys << k
           if !@results.key?(k)
-            @pending[k] ||= v
+            @pending[k] ||= normalize_fetch_key(v)
             pending_keys << k
           end
         }

data/lib/graphql/execution/interpreter.rb

@@ -93,13 +93,6 @@ module GraphQL
               # Then, work through lazy results in a breadth-first way
               multiplex.dataloader.append_job {
                 query = multiplex.queries.length == 1 ? multiplex.queries[0] : nil
-                queries = multiplex ? multiplex.queries : [query]
-                final_values = queries.map do |query|
-                  runtime = query.context.namespace(:interpreter_runtime)[:runtime]
-                  # it might not be present if the query has an error
-                  runtime ? runtime.final_result : nil
-                end
-                final_values.compact!
                 multiplex.current_trace.execute_query_lazy(multiplex: multiplex, query: query) do
                   Interpreter::Resolve.resolve_each_depth(lazies_at_depth, multiplex.dataloader)
                 end

data/lib/graphql/query/context.rb

@@ -39,9 +39,6 @@ module GraphQL
       # @return [GraphQL::Schema]
       attr_reader :schema
 
-      # @return [Array<String, Integer>] The current position in the result
-      attr_reader :path
-
       # Make a new context which delegates key lookup to `values`
       # @param query [GraphQL::Query] the query who owns this context
       # @param values [Hash] A hash of arbitrary values which will be accessible at query-time
@@ -53,9 +50,6 @@ module GraphQL
         @storage = Hash.new { |h, k| h[k] = {} }
         @storage[nil] = @provided_values
         @errors = []
-        @path = []
-        @value = nil
-        @context = self # for SharedMethods TODO delete sharedmethods
         @scoped_context = ScopedContext.new(self)
       end
 
@@ -245,7 +239,7 @@ module GraphQL
       end
 
       def inspect
-        "#<Query::Context ...>"
+        "#<#{self.class} ...>"
       end
 
       def scoped_merge!(hash)

data/lib/graphql/schema/input_object.rb

@@ -176,30 +176,33 @@ module GraphQL
             return GraphQL::Query::InputValidationResult.from_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
           end
 
-          # Inject missing required arguments
-          missing_required_inputs = ctx.types.arguments(self).reduce({}) do |m, (argument)|
-            if !input.key?(argument.graphql_name) && argument.type.non_null? && !argument.default_value? && types.argument(self, argument.graphql_name)
-              m[argument.graphql_name] = nil
-            end
-
-            m
-          end
 
           result = nil
-          [input, missing_required_inputs].each do |args_to_validate|
-            args_to_validate.each do |argument_name, value|
-              argument = types.argument(self, argument_name)
-              # Items in the input that are unexpected
-              if argument.nil?
-                result ||= Query::InputValidationResult.new
-                result.add_problem("Field is not defined on #{self.graphql_name}", [argument_name])
-              else
-                # Items in the input that are expected, but have invalid values
-                argument_result = argument.type.validate_input(value, ctx)
+
+
+          input.each do |argument_name, value|
+            argument = types.argument(self, argument_name)
+            # Items in the input that are unexpected
+            if argument.nil?
+              result ||= Query::InputValidationResult.new
+              result.add_problem("Field is not defined on #{self.graphql_name}", [argument_name])
+            else
+              # Items in the input that are expected, but have invalid values
+              argument_result = argument.type.validate_input(value, ctx)
+              if !argument_result.valid?
                 result ||= Query::InputValidationResult.new
-                if !argument_result.valid?
-                  result.merge_result!(argument_name, argument_result)
-                end
+                result.merge_result!(argument_name, argument_result)
+              end
+            end
+          end
+
+          # Check for missing non-null arguments
+          ctx.types.arguments(self).each do |argument|
+            if !input.key?(argument.graphql_name) && argument.type.non_null? && !argument.default_value?
+              result ||= Query::InputValidationResult.new
+              argument_result = argument.type.validate_input(nil, ctx)
+              if !argument_result.valid?
+                result.merge_result!(argument.graphql_name, argument_result)
               end
             end
           end

data/lib/graphql/schema/visibility.rb

@@ -12,7 +12,7 @@ module GraphQL
       # @param profiles [Hash<Symbol => Hash>] A hash of `name => context` pairs for preloading visibility profiles
       # @param preload [Boolean] if `true`, load the default schema profile and all named profiles immediately (defaults to `true` for `Rails.env.production?`)
       # @param migration_errors [Boolean] if `true`, raise an error when `Visibility` and `Warden` return different results
-      def self.use(schema, dynamic: false, profiles: EmptyObjects::EMPTY_HASH, preload: (defined?(Rails) ? Rails.env.production? : nil), migration_errors: false)
+      def self.use(schema, dynamic: false, profiles: EmptyObjects::EMPTY_HASH, preload: (defined?(Rails.env) ? Rails.env.production? : nil), migration_errors: false)
         profiles&.each { |name, ctx|
           ctx[:visibility_profile] = name
           ctx.freeze

data/lib/graphql/tracing/notifications_trace.rb

@@ -137,7 +137,9 @@ module GraphQL
 
       def dataloader_fiber_resume(source)
         prev_ev = Fiber[PREVIOUS_EV_KEY]
-        begin_notifications_event(prev_ev.name, prev_ev.payload)
+        if prev_ev
+          begin_notifications_event(prev_ev.name, prev_ev.payload)
+        end
         super
       end
 

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "2.5.3"
+  VERSION = "2.5.5"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.5.3
+  version: 2.5.5
 platform: ruby
 authors:
 - Robert Mosolgo
 bindir: bin
 cert_chain: []
-date: 2025-04-14 00:00:00.000000000 Z
+date: 2025-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -163,6 +163,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -801,7 +815,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.6
+rubygems_version: 3.6.8
 specification_version: 4
 summary: A GraphQL language and runtime for Ruby
 test_files: []