graphql 2.2.5 → 2.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49aca16aba9ee96f9aa4229e07e5493b1e8c676a892a1fa1e9828323d44dc073
-  data.tar.gz: 95eec1c3808a12b28bcc2732bb13baf9d52ddf3f34c4971abf92f6cff3333e93
+  metadata.gz: 573ce6f5423ca2d9eb0ca3dab40f01869501f834c3b48d5cac7f7c06fbf36da9
+  data.tar.gz: c3b1f0393d2838a2478a36a43cec88560832c220a3896f2ee4c715d013d1758c
 SHA512:
-  metadata.gz: 287acc2969a3b181d2d53dc94562335fac43de4cb8873844f063b63b604948e3edb7df318e53ec42906f678f7329efc5aa8d28bdbbfd4bc7f9d504a96f745df9
-  data.tar.gz: 3ef6c000a5eeaddd295786e9baf147663556cc19c1bc46facf57b67233bf40780e42b4781f39ebd3966ca29bc6bab6b682e9bd475b4c2474f471841454cb3d3c
+  metadata.gz: 14d6c96c20c8fdb56ecddf0279e24e83c862d4133c72b3cebc44dca9e40e1c684b4f4a4c45fca81451d48d1bb97a4e6c3ae13499a40e12a76926e679a12a13f2
+  data.tar.gz: 44157aaa761da8c9f82afa9e31533ee3c87cdf4257256ec84f70f0e30dff8dc1830486c2ff02b4464a67e8815518466451ae598eabc12249cf2edaad6a9371f1

data/lib/generators/graphql/templates/schema.erb

@@ -26,6 +26,9 @@ class <%= schema_name %> < GraphQL::Schema
     raise(GraphQL::RequiredImplementationMissingError)
   end
 
+  # Limit the size of incoming queries:
+  max_query_string_tokens(5000)
+
   # Stop validating when it encounters this many errors:
   validate_max_errors(100)
 end

data/lib/graphql/analysis/ast/field_usage.rb

@@ -8,6 +8,7 @@ module GraphQL
           @used_fields = Set.new
           @used_deprecated_fields = Set.new
           @used_deprecated_arguments = Set.new
+          @used_deprecated_enum_values = Set.new
         end
 
         def on_leave_field(node, parent, visitor)
@@ -15,7 +16,7 @@ module GraphQL
           field = "#{visitor.parent_type_definition.graphql_name}.#{field_defn.graphql_name}"
           @used_fields << field
           @used_deprecated_fields << field if field_defn.deprecation_reason
-          arguments = visitor.query.arguments_for(node, visitor.field_definition)
+          arguments = visitor.query.arguments_for(node, field_defn)
           # If there was an error when preparing this argument object,
           # then this might be an error or something:
           if arguments.respond_to?(:argument_values)
@@ -28,6 +29,7 @@ module GraphQL
             used_fields: @used_fields.to_a,
             used_deprecated_fields: @used_deprecated_fields.to_a,
             used_deprecated_arguments: @used_deprecated_arguments.to_a,
+            used_deprecated_enum_values: @used_deprecated_enum_values.to_a,
           }
         end
 
@@ -39,18 +41,43 @@ module GraphQL
               @used_deprecated_arguments << argument.definition.path
             end
 
-            next if argument.value.nil?
+            arg_val = argument.value
 
-            if argument.definition.type.kind.input_object?
-              extract_deprecated_arguments(argument.value.arguments.argument_values) # rubocop:disable Development/ContextIsPassedCop -- runtime args instance
-            elsif argument.definition.type.list?
-              argument
-                .value
-                .select { |value| value.respond_to?(:arguments) }
-                .each { |value| extract_deprecated_arguments(value.arguments.argument_values) } # rubocop:disable Development/ContextIsPassedCop -- runtime args instance
+            next if arg_val.nil?
+
+            argument_type = argument.definition.type
+            if argument_type.non_null?
+              argument_type = argument_type.of_type
+            end
+
+            if argument_type.kind.input_object?
+              extract_deprecated_arguments(argument.original_value.arguments.argument_values) # rubocop:disable Development/ContextIsPassedCop -- runtime args instance
+            elsif argument_type.kind.enum?
+              extract_deprecated_enum_value(argument_type, arg_val)
+            elsif argument_type.list?
+              inner_type = argument_type.unwrap
+              case inner_type.kind
+              when TypeKinds::INPUT_OBJECT
+                argument.original_value.each do |value|
+                  extract_deprecated_arguments(value.arguments.argument_values) # rubocop:disable Development/ContextIsPassedCop -- runtime args instance
+                end
+              when TypeKinds::ENUM
+                arg_val.each do |value|
+                  extract_deprecated_enum_value(inner_type, value)
+                end
+              else
+                # Not a kind of input that we track
+              end
             end
           end
         end
+
+        def extract_deprecated_enum_value(enum_type, value)
+          enum_value = @query.warden.enum_values(enum_type).find { |ev| ev.value == value }
+          if enum_value&.deprecation_reason
+            @used_deprecated_enum_values << enum_value.path
+          end
+        end
       end
     end
   end

data/lib/graphql/analysis/ast/visitor.rb

@@ -118,8 +118,12 @@ module GraphQL
         def on_inline_fragment(node, parent)
           on_fragment_with_type(node) do
             @path.push("...#{node.type ? " on #{node.type.name}" : ""}")
+            @skipping = @skip_stack.last || skip?(node)
+            @skip_stack << @skipping
+
             call_on_enter_inline_fragment(node, parent)
             super
+            @skipping = @skip_stack.pop
             call_on_leave_inline_fragment(node, parent)
           end
         end
@@ -187,9 +191,13 @@ module GraphQL
 
         def on_fragment_spread(node, parent)
           @path.push("... #{node.name}")
+          @skipping = @skip_stack.last || skip?(node)
+          @skip_stack << @skipping
+
           call_on_enter_fragment_spread(node, parent)
           enter_fragment_spread_inline(node)
           super
+          @skipping = @skip_stack.pop
           leave_fragment_spread_inline(node)
           call_on_leave_fragment_spread(node, parent)
           @path.pop

data/lib/graphql/analysis/ast.rb

@@ -6,6 +6,7 @@ require "graphql/analysis/ast/query_complexity"
 require "graphql/analysis/ast/max_query_complexity"
 require "graphql/analysis/ast/query_depth"
 require "graphql/analysis/ast/max_query_depth"
+require "timeout"
 
 module GraphQL
   module Analysis
@@ -63,7 +64,10 @@ module GraphQL
                 analyzers: analyzers_to_run
               )
 
-              visitor.visit
+              # `nil` or `0` causes no timeout
+              Timeout::timeout(query.validate_timeout_remaining) do
+                visitor.visit
+              end
 
               if visitor.rescued_errors.any?
                 return visitor.rescued_errors
@@ -75,6 +79,11 @@ module GraphQL
             []
           end
         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/backtrace/inspect_result.rb

@@ -16,12 +16,6 @@ module GraphQL
           "[" +
             obj.map { |v| inspect_truncated(v) }.join(", ") +
             "]"
-        when Query::Context::SharedMethods
-          if obj.invalid_null?
-            "nil"
-          else
-            inspect_truncated(obj.value)
-          end
         else
           inspect_truncated(obj)
         end
@@ -33,12 +27,6 @@ module GraphQL
           "{...}"
         when Array
           "[...]"
-        when Query::Context::SharedMethods
-          if obj.invalid_null?
-            "nil"
-          else
-            inspect_truncated(obj.value)
-          end
         when GraphQL::Execution::Lazy
           "(unresolved)"
         else

data/lib/graphql/coercion_error.rb

@@ -1,13 +1,5 @@
 # frozen_string_literal: true
 module GraphQL
-  class CoercionError < GraphQL::Error
-    # @return [Hash] Optional custom data for error objects which will be added
-    # under the `extensions` key.
-    attr_accessor :extensions
-
-    def initialize(message, extensions: nil)
-      @extensions = extensions
-      super(message)
-    end
+  class CoercionError < GraphQL::ExecutionError
   end
 end

data/lib/graphql/dataloader/request.rb

@@ -14,6 +14,11 @@ module GraphQL
       def load
         @source.load(@key)
       end
+
+      def load_with_deprecation_warning
+        warn("Returning `.request(...)` from GraphQL::Dataloader is deprecated, use `.load(...)` instead. (See usage of #{@source} with #{@key.inspect}).")
+        load
+      end
     end
   end
 end

data/lib/graphql/execution/interpreter/argument_value.rb

@@ -6,15 +6,19 @@ module GraphQL
       # A container for metadata regarding arguments present in a GraphQL query.
       # @see Interpreter::Arguments#argument_values for a hash of these objects.
       class ArgumentValue
-        def initialize(definition:, value:, default_used:)
+        def initialize(definition:, value:, original_value:, default_used:)
           @definition = definition
           @value = value
+          @original_value = original_value
           @default_used = default_used
         end
 
         # @return [Object] The Ruby-ready value for this Argument
         attr_reader :value
 
+        # @return [Object] The value of this argument _before_ `prepare` is applied.
+        attr_reader :original_value
+
         # @return [GraphQL::Schema::Argument] The definition instance for this argument
         attr_reader :definition
 

data/lib/graphql/execution/interpreter/runtime.rb

@@ -352,6 +352,15 @@ module GraphQL
           end
 
           field_result = call_method_on_directives(:resolve, object, directives) do
+            if directives.any?
+              # This might be executed in a different context; reset this info
+              runtime_state = get_current_runtime_state
+              runtime_state.current_field = field_defn
+              runtime_state.current_object = object
+              runtime_state.current_arguments = resolved_arguments
+              runtime_state.current_result_name = result_name
+              runtime_state.current_result = selection_result
+            end
             # Actually call the field resolver and capture the result
             app_result = begin
               @current_trace.execute_field(field: field_defn, ast_node: ast_node, query: query, object: object, arguments: kwarg_arguments) do

data/lib/graphql/execution/interpreter.rb

@@ -37,173 +37,113 @@ module GraphQL
           multiplex.current_trace.execute_multiplex(multiplex: multiplex) do
             schema = multiplex.schema
             queries = multiplex.queries
-            query_instrumenters = schema.instrumenters[:query]
-            multiplex_instrumenters = schema.instrumenters[:multiplex]
             lazies_at_depth = Hash.new { |h, k| h[k] = [] }
+            multiplex_analyzers = schema.multiplex_analyzers
+            if multiplex.max_complexity
+              multiplex_analyzers += [GraphQL::Analysis::AST::MaxQueryComplexity]
+            end
 
-            # First, run multiplex instrumentation, then query instrumentation for each query
-            call_hooks(multiplex_instrumenters, multiplex, :before_multiplex, :after_multiplex) do
-              each_query_call_hooks(query_instrumenters, queries) do
-                schema = multiplex.schema
-                multiplex_analyzers = schema.multiplex_analyzers
-                queries = multiplex.queries
-                if multiplex.max_complexity
-                  multiplex_analyzers += [GraphQL::Analysis::AST::MaxQueryComplexity]
+            schema.analysis_engine.analyze_multiplex(multiplex, multiplex_analyzers)
+            begin
+              # Since this is basically the batching context,
+              # share it for a whole multiplex
+              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|
+                if query.subscription? && !query.subscription_update?
+                  query.context.namespace(:subscriptions)[:events] = []
                 end
-
-                schema.analysis_engine.analyze_multiplex(multiplex, multiplex_analyzers)
-                begin
-                  # Since this is basically the batching context,
-                  # share it for a whole multiplex
-                  multiplex.context[:interpreter_instance] ||= multiplex.schema.query_execution_strategy.new
-                  # Do as much eager evaluation of the query as possible
-                  results = []
-                  queries.each_with_index do |query, idx|
-                    multiplex.dataloader.append_job {
-                      operation = query.selected_operation
-                      result = if operation.nil? || !query.valid? || query.context.errors.any?
-                        NO_OPERATION
-                      else
-                        begin
-                          # Although queries in a multiplex _share_ an Interpreter instance,
-                          # they also have another item of state, which is private to that query
-                          # in particular, assign it here:
-                          runtime = Runtime.new(query: query, lazies_at_depth: lazies_at_depth)
-                          query.context.namespace(:interpreter_runtime)[:runtime] = runtime
-
-                          query.current_trace.execute_query(query: query) do
-                            runtime.run_eager
-                          end
-                        rescue GraphQL::ExecutionError => err
-                          query.context.errors << err
-                          NO_OPERATION
-                        end
+                multiplex.dataloader.append_job {
+                  operation = query.selected_operation
+                  result = if operation.nil? || !query.valid? || query.context.errors.any?
+                    NO_OPERATION
+                  else
+                    begin
+                      # Although queries in a multiplex _share_ an Interpreter instance,
+                      # they also have another item of state, which is private to that query
+                      # in particular, assign it here:
+                      runtime = Runtime.new(query: query, lazies_at_depth: lazies_at_depth)
+                      query.context.namespace(:interpreter_runtime)[:runtime] = runtime
+
+                      query.current_trace.execute_query(query: query) do
+                        runtime.run_eager
                       end
-                      results[idx] = result
-                    }
+                    rescue GraphQL::ExecutionError => err
+                      query.context.errors << err
+                      NO_OPERATION
+                    end
                   end
+                  results[idx] = result
+                }
+              end
 
-                  multiplex.dataloader.run
+              multiplex.dataloader.run
 
-                  # 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
-                  }
-                  multiplex.dataloader.run
-
-                  # Then, find all errors and assign the result to the query object
-                  results.each_with_index do |data_result, idx|
-                    query = queries[idx]
-                    # Assign the result so that it can be accessed in instrumentation
-                    query.result_values = if data_result.equal?(NO_OPERATION)
-                      if !query.valid? || query.context.errors.any?
-                        # A bit weird, but `Query#static_errors` _includes_ `query.context.errors`
-                        { "errors" => query.static_errors.map(&:to_h) }
-                      else
-                        data_result
-                      end
-                    else
-                      result = {
-                        "data" => query.context.namespace(:interpreter_runtime)[:runtime].final_result
-                      }
+              # 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
+              }
+              multiplex.dataloader.run
 
-                      if query.context.errors.any?
-                        error_result = query.context.errors.map(&:to_h)
-                        result["errors"] = error_result
-                      end
+              # Then, find all errors and assign the result to the query object
+              results.each_with_index do |data_result, idx|
+                query = queries[idx]
+                if (events = query.context.namespace(:subscriptions)[:events]) && events.any?
+                  schema.subscriptions.write_subscription(query, events)
+                end
+                # Assign the result so that it can be accessed in instrumentation
+                query.result_values = if data_result.equal?(NO_OPERATION)
+                  if !query.valid? || query.context.errors.any?
+                    # A bit weird, but `Query#static_errors` _includes_ `query.context.errors`
+                    { "errors" => query.static_errors.map(&:to_h) }
+                  else
+                    data_result
+                  end
+                else
+                  result = {}
 
-                      result
-                    end
-                    if query.context.namespace?(:__query_result_extensions__)
-                      query.result_values["extensions"] = query.context.namespace(:__query_result_extensions__)
-                    end
-                    # Get the Query::Result, not the Hash
-                    results[idx] = query.result
+                  if query.context.errors.any?
+                    error_result = query.context.errors.map(&:to_h)
+                    result["errors"] = error_result
                   end
 
-                  results
-                rescue Exception
-                  # TODO rescue at a higher level so it will catch errors in analysis, too
-                  # Assign values here so that the query's `@executed` becomes true
-                  queries.map { |q| q.result_values ||= {} }
-                  raise
-                ensure
-                  queries.map { |query|
-                    runtime = query.context.namespace(:interpreter_runtime)[:runtime]
-                    if runtime
-                      runtime.delete_all_interpreter_context
-                    end
-                  }
+                  result["data"] = query.context.namespace(:interpreter_runtime)[:runtime].final_result
+
+                  result
+                end
+                if query.context.namespace?(:__query_result_extensions__)
+                  query.result_values["extensions"] = query.context.namespace(:__query_result_extensions__)
                 end
+                # Get the Query::Result, not the Hash
+                results[idx] = query.result
               end
-            end
-          end
-        end
 
-        private
-
-        # Call the before_ hooks of each query,
-        # Then yield if no errors.
-        # `call_hooks` takes care of appropriate cleanup.
-        def each_query_call_hooks(instrumenters, queries, i = 0)
-          if i >= queries.length
-            yield
-          else
-            query = queries[i]
-            call_hooks(instrumenters, query, :before_query, :after_query) {
-              each_query_call_hooks(instrumenters, queries, i + 1) {
-                yield
+              results
+            rescue Exception
+              # TODO rescue at a higher level so it will catch errors in analysis, too
+              # Assign values here so that the query's `@executed` becomes true
+              queries.map { |q| q.result_values ||= {} }
+              raise
+            ensure
+              queries.map { |query|
+                runtime = query.context.namespace(:interpreter_runtime)[:runtime]
+                if runtime
+                  runtime.delete_all_interpreter_context
+                end
               }
-            }
-          end
-        end
-
-        # Call each before hook, and if they all succeed, yield.
-        # If they don't all succeed, call after_ for each one that succeeded.
-        def call_hooks(instrumenters, object, before_hook_name, after_hook_name)
-          begin
-            successful = []
-            instrumenters.each do |instrumenter|
-              instrumenter.public_send(before_hook_name, object)
-              successful << instrumenter
-            end
-
-            # if any before hooks raise an exception, quit calling before hooks,
-            # but call the after hooks on anything that succeeded but also
-            # raise the exception that came from the before hook.
-          rescue GraphQL::ExecutionError => err
-            object.context.errors << err
-          rescue => e
-            raise call_after_hooks(successful, object, after_hook_name, e)
-          end
-
-          begin
-            yield # Call the user code
-          ensure
-            ex = call_after_hooks(successful, object, after_hook_name, nil)
-            raise ex if ex
-          end
-        end
-
-        def call_after_hooks(instrumenters, object, after_hook_name, ex)
-          instrumenters.reverse_each do |instrumenter|
-            begin
-              instrumenter.public_send(after_hook_name, object)
-            rescue => e
-              ex = e
             end
           end
-          ex
         end
       end
 

data/lib/graphql/introspection/entry_points.rb

@@ -9,13 +9,19 @@ module GraphQL
 
       def __schema
         # Apply wrapping manually since this field isn't wrapped by instrumentation
-        schema = @context.query.schema
+        schema = context.schema
         schema_type = schema.introspection_system.types["__Schema"]
-        schema_type.wrap(schema, @context)
+        schema_type.wrap(schema, context)
       end
 
       def __type(name:)
-        context.warden.reachable_type?(name) ? context.warden.get_type(name) : nil
+        if context.warden.reachable_type?(name)
+          context.warden.get_type(name)
+        elsif (type = context.schema.extra_types.find { |t| t.graphql_name == name })
+          type
+        else
+          nil
+        end
       end
     end
   end

data/lib/graphql/introspection/schema_type.rb

@@ -20,7 +20,9 @@ module GraphQL
       end
 
       def types
-        @context.warden.reachable_types.sort_by(&:graphql_name)
+        types = context.warden.reachable_types + context.schema.extra_types
+        types.sort_by!(&:graphql_name)
+        types
       end
 
       def query_type

data/lib/graphql/language/document_from_schema_definition.rb

@@ -24,7 +24,7 @@ module GraphQL
         @include_built_in_directives = include_built_in_directives
         @include_one_of = false
 
-        schema_context = schema.context_class.new(query: nil, object: nil, schema: schema, values: context)
+        schema_context = schema.context_class.new(query: nil, schema: schema, values: context)
 
 
         @warden = @schema.warden_class.new(
@@ -266,8 +266,7 @@ module GraphQL
         end
         definitions = build_directive_nodes(dirs_to_build)
 
-        type_nodes = build_type_definition_nodes(warden.reachable_types)
-
+        type_nodes = build_type_definition_nodes(warden.reachable_types + schema.extra_types)
         if @include_one_of
           # This may have been set to true when iterating over all types
           definitions.concat(build_directive_nodes([GraphQL::Schema::Directive::OneOf]))