graphql 2.2.10 → 2.2.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ed6a9339a1c67dca4307a9753eeb5c25d8ff6cd32fa156de65e852ddb21f5e9
-  data.tar.gz: 0ed35f51512eba4f60fa1c16d80d267f800c516d174c024d8beaa68fbcca3d33
+  metadata.gz: 4bcb377d757eba98e3b88e8a3af21bacbf00b7bb28ee994b7d517b5fb296c47a
+  data.tar.gz: 43a94034f284af6ecb62dd0961a67e706a7032000c7c500a8029a02995dd1881
 SHA512:
-  metadata.gz: 159a9c932168794b7d4446ed0b207269c6f4ca05c45542c7632816a8bb0449b024f4879be95d8b762b0eb5e8969a31ce28915ec53853d4f67559d952908e59e2
-  data.tar.gz: f153e397dd3b83504ca97ff44ac3f479228d7d18df5bf24879c8e8a8113e54d61ba26b8b9c74516bc05d47cb7febfcd507b12e6f3d42988b8dad9b5e3a7fa211
+  metadata.gz: bb67bbe99e21ce0f88632d6f5e965e842ff2714540d924721fb9234d9502b8ed596954c2748c406079052799386075f65d079c0e900df38c06f1cb1d422c61d8
+  data.tar.gz: 2e982944076364c91bc5dac75ff496762d973b0eed0c7b5913e27f5e01de0c0c2394047343c90e96f3f4d54db055adabf0268377bed6d6a06784b2f941b13ac7

data/lib/graphql/analysis/ast.rb

@@ -81,6 +81,9 @@ module GraphQL
         end
       rescue Timeout::Error
         [GraphQL::AnalysisError.new("Timeout on validation of query")]
+      rescue GraphQL::UnauthorizedError
+        # This error was raised during analysis and will be returned the client before execution
+        []
       end
 
       def analysis_errors(results)

data/lib/graphql/execution/interpreter.rb

@@ -47,7 +47,7 @@ module GraphQL
             begin
               # Since this is basically the batching context,
               # share it for a whole multiplex
-              multiplex.context[:interpreter_instance] ||= multiplex.schema.query_execution_strategy.new
+              multiplex.context[:interpreter_instance] ||= multiplex.schema.query_execution_strategy(deprecation_warning: false).new
               # Do as much eager evaluation of the query as possible
               results = []
               queries.each_with_index do |query, idx|

data/lib/graphql/pagination/array_connection.rb

@@ -56,12 +56,12 @@ module GraphQL
             false
           end
 
-          @has_next_page = if first_value && first
-            # There are more items after these items
-            sliced_nodes.count > first
-          elsif before
+          @has_next_page = if before
             # The original array is longer than the `before` index
             index_from_cursor(before) < items.length + 1
+          elsif first
+            # There are more items after these items
+            sliced_nodes.count > first
           else
             false
           end

data/lib/graphql/pagination/relation_connection.rb

@@ -29,14 +29,14 @@ module GraphQL
 
       def has_next_page
         if @has_next_page.nil?
-          @has_next_page = if first && first_value
+          @has_next_page = if before_offset && before_offset > 0
+            true
+          elsif first
             if @nodes && @nodes.count < first
               false
             else
               relation_larger_than(sliced_nodes, @sliced_nodes_offset, first)
             end
-          elsif before_offset && before_offset > 0
-            true
           else
             false
           end

data/lib/graphql/schema/field.rb

@@ -471,6 +471,8 @@ module GraphQL
             if arguments[:last] && (max_possible_page_size.nil? || arguments[:last] > max_possible_page_size)
               max_possible_page_size = arguments[:last]
             end
+          elsif arguments.is_a?(GraphQL::UnauthorizedError)
+            raise arguments
           end
 
           if max_possible_page_size.nil?

data/lib/graphql/schema/member/has_arguments.rb

@@ -50,7 +50,7 @@ module GraphQL
             if loads && arg_defn.type.list?
               class_eval <<-RUBY, __FILE__, __LINE__ + 1
               def #{method_owner}load_#{arg_defn.keyword}(values, context = nil)
-                argument = get_argument("#{arg_defn.graphql_name}")
+                argument = get_argument("#{arg_defn.graphql_name}", context || self.context)
                 (context || self.context).query.after_lazy(values) do |values2|
                   GraphQL::Execution::Lazy.all(values2.map { |value| load_application_object(argument, value, context || self.context) })
                 end
@@ -59,7 +59,7 @@ module GraphQL
             elsif loads
               class_eval <<-RUBY, __FILE__, __LINE__ + 1
               def #{method_owner}load_#{arg_defn.keyword}(value, context = nil)
-                argument = get_argument("#{arg_defn.graphql_name}")
+                argument = get_argument("#{arg_defn.graphql_name}", context || self.context)
                 load_application_object(argument, value, context || self.context)
               end
               RUBY

data/lib/graphql/schema.rb

@@ -63,10 +63,6 @@ module GraphQL
   # Schemas can restrict large incoming queries with `max_depth` and `max_complexity` configurations.
   # (These configurations can be overridden by specific calls to {Schema#execute})
   #
-  # Schemas can specify how queries should be executed against them.
-  # `query_execution_strategy`, `mutation_execution_strategy` and `subscription_execution_strategy`
-  # each apply to corresponding root types.
-  #
   # @example defining a schema
   #   class MySchema < GraphQL::Schema
   #     query QueryType
@@ -167,13 +163,20 @@ module GraphQL
           backtrace_class.include(GraphQL::Backtrace::Trace)
           trace_mode(:default_backtrace, backtrace_class)
         end
-        trace_class_for(:default)
+        trace_class_for(:default, build: true)
       end
 
       # @return [Class] Return the trace class to use for this mode, looking one up on the superclass if this Schema doesn't have one defined.
-      def trace_class_for(mode, build: true)
-        own_trace_modes[mode] ||
-          (superclass.respond_to?(:trace_class_for) ? superclass.trace_class_for(mode, build: build) : (build ? (own_trace_modes[mode] = build_trace_mode(mode)) : nil))
+      def trace_class_for(mode, build: false)
+        if (trace_class = own_trace_modes[mode])
+          trace_class
+        elsif superclass.respond_to?(:trace_class_for) && (trace_class = superclass.trace_class_for(mode, build: false))
+          trace_class
+        elsif build
+          own_trace_modes[mode] = build_trace_mode(mode)
+        else
+          nil
+        end
       end
 
       # Configure `trace_class` to be used whenever `context: { trace_mode: mode_name }` is requested.
@@ -211,14 +214,14 @@ module GraphQL
             include DefaultTraceClass
           end
         when :default_backtrace
-          schema_base_class = trace_class_for(:default)
+          schema_base_class = trace_class_for(:default, build: true)
           Class.new(schema_base_class) do
             include(GraphQL::Backtrace::Trace)
           end
         else
           # First, see if the superclass has a custom-defined class for this.
           # Then, if it doesn't, use this class's default trace
-          base_class = (superclass.respond_to?(:trace_class_for) && superclass.trace_class_for(mode, build: false)) || trace_class_for(:default)
+          base_class = (superclass.respond_to?(:trace_class_for) && superclass.trace_class_for(mode)) || trace_class_for(:default, build: true)
           # Prepare the default trace class if it hasn't been initialized yet
           base_class ||= (own_trace_modes[:default] = build_trace_mode(:default))
           mods = trace_modules_for(mode)
@@ -644,27 +647,39 @@ module GraphQL
         end
       end
 
-      def query_execution_strategy(new_query_execution_strategy = nil)
+      def query_execution_strategy(new_query_execution_strategy = nil, deprecation_warning: true)
+        if deprecation_warning
+          warn "GraphQL::Schema.query_execution_strategy is deprecated without replacement. Use `GraphQL::Query.new` directly to create and execute a custom query instead."
+          warn "  #{caller(1, 1).first}"
+        end
         if new_query_execution_strategy
           @query_execution_strategy = new_query_execution_strategy
         else
-          @query_execution_strategy || find_inherited_value(:query_execution_strategy, self.default_execution_strategy)
+          @query_execution_strategy || (superclass.respond_to?(:query_execution_strategy) ? superclass.query_execution_strategy(deprecation_warning: false) : self.default_execution_strategy)
         end
       end
 
-      def mutation_execution_strategy(new_mutation_execution_strategy = nil)
+      def mutation_execution_strategy(new_mutation_execution_strategy = nil, deprecation_warning: true)
+        if deprecation_warning
+          warn "GraphQL::Schema.mutation_execution_strategy is deprecated without replacement. Use `GraphQL::Query.new` directly to create and execute a custom query instead."
+            warn "  #{caller(1, 1).first}"
+        end
         if new_mutation_execution_strategy
           @mutation_execution_strategy = new_mutation_execution_strategy
         else
-          @mutation_execution_strategy || find_inherited_value(:mutation_execution_strategy, self.default_execution_strategy)
+          @mutation_execution_strategy || (superclass.respond_to?(:mutation_execution_strategy) ? superclass.mutation_execution_strategy(deprecation_warning: false) : self.default_execution_strategy)
         end
       end
 
-      def subscription_execution_strategy(new_subscription_execution_strategy = nil)
+      def subscription_execution_strategy(new_subscription_execution_strategy = nil, deprecation_warning: true)
+        if deprecation_warning
+          warn "GraphQL::Schema.subscription_execution_strategy is deprecated without replacement. Use `GraphQL::Query.new` directly to create and execute a custom query instead."
+          warn "  #{caller(1, 1).first}"
+        end
         if new_subscription_execution_strategy
           @subscription_execution_strategy = new_subscription_execution_strategy
         else
-          @subscription_execution_strategy || find_inherited_value(:subscription_execution_strategy, self.default_execution_strategy)
+          @subscription_execution_strategy || (superclass.respond_to?(:subscription_execution_strategy) ? superclass.subscription_execution_strategy(deprecation_warning: false) : self.default_execution_strategy)
         end
       end
 
@@ -1111,7 +1126,7 @@ module GraphQL
       end
 
       def tracer(new_tracer)
-        default_trace = trace_class_for(:default)
+        default_trace = trace_class_for(:default, build: true)
         if default_trace.nil? || !(default_trace < GraphQL::Tracing::CallLegacyTracers)
           trace_with(GraphQL::Tracing::CallLegacyTracers)
         end
@@ -1163,10 +1178,14 @@ module GraphQL
       def trace_options_for(mode)
         @trace_options_for_mode ||= {}
         @trace_options_for_mode[mode] ||= begin
+          # It may be time to create an options hash for a mode that wasn't registered yet.
+          # Mix in the default options in that case.
+          default_options = mode == :default ? EMPTY_HASH : trace_options_for(:default)
+          # Make sure this returns a new object so that other hashes aren't modified later
           if superclass.respond_to?(:trace_options_for)
-            superclass.trace_options_for(mode).dup
+            superclass.trace_options_for(mode).merge(default_options)
           else
-            {}
+            default_options.dup
           end
         end
       end
@@ -1199,7 +1218,7 @@ module GraphQL
         options_trace_mode ||= trace_mode
         base_trace_options = trace_options_for(options_trace_mode)
         trace_options = base_trace_options.merge(options)
-        trace_class_for_mode = trace_class_for(trace_mode) || raise(ArgumentError, "#{self} has no trace class for mode: #{trace_mode.inspect}")
+        trace_class_for_mode = trace_class_for(trace_mode, build: true)
         trace_class_for_mode.new(**trace_options)
       end
 

data/lib/graphql/tracing/sentry_trace.rb

@@ -5,6 +5,24 @@ module GraphQL
     module SentryTrace
       include PlatformTrace
 
+      # @param set_transaction_name [Boolean] If true, the GraphQL operation name will be used as the transaction name.
+      #   This is not advised if you run more than one query per HTTP request, for example, with `graphql-client` or multiplexing.
+      #   It can also be specified per-query with `context[:set_sentry_transaction_name]`.
+      def initialize(set_transaction_name: false, **_rest)
+        @set_transaction_name = set_transaction_name
+        super
+      end
+      
+      def execute_query(**data)
+        set_this_txn_name = data[:query].context[:set_sentry_transaction_name]
+        if set_this_txn_name == true || (set_this_txn_name.nil? && @set_transaction_name)
+          Sentry.configure_scope do |scope|
+            scope.set_transaction_name(transaction_name(data[:query]))
+          end
+        end
+        instrument_execution("graphql.execute", "execute_query", data) { super }
+      end
+
       {
         "lex" => "graphql.lex",
         "parse" => "graphql.parse",
@@ -12,7 +30,6 @@ module GraphQL
         "analyze_query" => "graphql.analyze",
         "analyze_multiplex" => "graphql.analyze_multiplex",
         "execute_multiplex" => "graphql.execute_multiplex",
-        "execute_query" => "graphql.execute",
         "execute_query_lazy" => "graphql.execute"
       }.each do |trace_method, platform_key|
         module_eval <<-RUBY, __FILE__, __LINE__

data/lib/graphql/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.2.10
+  version: 2.2.12
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-20 00:00:00.000000000 Z
+date: 2024-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -631,7 +631,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.5
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: A GraphQL language and runtime for Ruby