graphql 1.13.12 → 2.0.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90fcd1d4c840be80d47ed66bad6c4cdd4c16a4981b249b57e7e126a3ff5d5d6d
-  data.tar.gz: 6d9f87843cd626dff3a9f46158fce7f1be22c3f1aa4131c8b2390b82f93edb52
+  metadata.gz: 43f1cc3ef36a54a31f8afa03ee3109b34f046e26c427acfb80599a2dd245cf14
+  data.tar.gz: 4e4a15c766650e36004175de15cfcb9f67c6b4e7d24e2f91712a6ad3f8681453
 SHA512:
-  metadata.gz: 355972194b55f12d4bc43d610249c94ce6d73c574f12688863b01bf60ad4f2a9ad093ee19c76403f4b84371583ea5c236a3d7cfda72e3564a222dd9f12c1d0ea
-  data.tar.gz: 5ebd795ac0884a46f413e4ede96165d3b2be2489266c36fbc06d90f0d940e69a2afa86c86417757716dc47ddc9c3bdbbe475c7f1547951c5cbe843a0ed7d45e5
+  metadata.gz: 908f3790bcc773bb6c7fe3db1f5e2ccabf361ece7b462b80fc4e59911167eabb8baf544739f31ac425579bca61b56b46937ac60e7a54a03827228016457388de
+  data.tar.gz: 62fb9dc90ab55aff66d3d1621fc28b18c0c9599e2f8a7f8521d372a6f549c85ac0a2e50a0d43cb77bde728cb44f85b178bb37388c6bd3d2aed5f8e91723a79ef

data/lib/generators/graphql/install_generator.rb

@@ -47,7 +47,7 @@ module Graphql
     #
     # Accept a `--batch` option which adds `GraphQL::Batch` setup.
     #
-    # Use `--no-graphiql` to skip `graphiql-rails` installation.
+    # Use `--skip-graphiql` to skip `graphiql-rails` installation.
     #
     # TODO: also add base classes
     class InstallGenerator < Rails::Generators::Base

data/lib/generators/graphql/relay.rb

@@ -33,27 +33,13 @@ module Graphql
   # Return a string UUID for `object`
   def self.id_from_object(object, type_definition, query_ctx)
     # For example, use Rails' GlobalID library (https://github.com/rails/globalid):
-    object_id = object.to_global_id.to_s
-    # Remove this redundant prefix to make IDs shorter:
-    object_id = object_id.sub("gid://\#{GlobalID.app}/", "")
-    encoded_id = Base64.urlsafe_encode64(object_id)
-    # Remove the "=" padding
-    encoded_id = encoded_id.sub(/=+/, "")
-    # Add a type hint
-    type_hint = type_definition.graphql_name.first
-    "\#{type_hint}_\#{encoded_id}"
+    object.to_gid_param
   end
 
   # Given a string UUID, find the object
-  def self.object_from_id(encoded_id_with_hint, query_ctx)
+  def self.object_from_id(global_id, query_ctx)
     # For example, use Rails' GlobalID library (https://github.com/rails/globalid):
-    # Split off the type hint
-    _type_hint, encoded_id = encoded_id_with_hint.split("_", 2)
-    # Decode the ID
-    id = Base64.urlsafe_decode64(encoded_id)
-    # Rebuild it for Rails then find the object:
-    full_global_id = "gid://\#{GlobalID.app}/\#{id}"
-    GlobalID::Locator.locate(full_global_id)
+    GlobalID.find(global_id)
   end
 RUBY
         inject_into_file schema_file_path, schema_code, before: /^end\n/m, force: false

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

@@ -23,5 +23,8 @@ class <%= schema_name %> < GraphQL::Schema
     # to return the correct GraphQL object type for `obj`
     raise(GraphQL::RequiredImplementationMissingError)
   end
+
+  # Stop validating when it encounters this many errors:
+  validate_max_errors(100)
 end
 <% end -%>

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

@@ -39,9 +39,11 @@ module GraphQL
               @used_deprecated_arguments << argument.definition.path
             end
 
+            next if argument.value.nil?
+
             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.nil?
+            elsif argument.definition.type.list?
               argument
                 .value
                 .select { |value| value.respond_to?(:arguments) }

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

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require_relative "./query_complexity"
 module GraphQL
   module Analysis
     module AST

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

@@ -5,7 +5,7 @@ module GraphQL
     module AST
       class QueryComplexity < Analyzer
         # State for the query complexity calculation:
-        # - `complexities_on_type` holds complexity scores for each type in an IRep node
+        # - `complexities_on_type` holds complexity scores for each type
         def initialize(query)
           super
           @complexities_on_type_by_query = {}

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

@@ -15,7 +15,6 @@ module GraphQL
     #   # In your Schema file:
     #
     #   class MySchema < GraphQL::Schema
-    #     use GraphQL::Analysis::AST
     #     query_analyzer LogQueryDepth
     #   end
     #

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

@@ -43,7 +43,7 @@ module GraphQL
 
         # Visit Helpers
 
-        # @return [GraphQL::Query::Arguments] Arguments for this node, merging default values, literal values and query variables
+        # @return [GraphQL::Execution::Interpreter::Arguments] Arguments for this node, merging default values, literal values and query variables
         # @see {GraphQL::Query#arguments_for}
         def arguments_for(ast_node, field_definition)
           @query.arguments_for(ast_node, field_definition)
@@ -65,14 +65,41 @@ module GraphQL
         end
 
         # Visitor Hooks
+        [
+          :operation_definition, :fragment_definition,
+          :inline_fragment, :field, :directive, :argument, :fragment_spread
+        ].each do |node_type|
+          module_eval <<-RUBY, __FILE__, __LINE__
+          def call_on_enter_#{node_type}(node, parent)
+            @analyzers.each do |a|
+              begin
+                a.on_enter_#{node_type}(node, parent, self)
+              rescue AnalysisError => err
+                @rescued_errors << err
+              end
+            end
+          end
+
+          def call_on_leave_#{node_type}(node, parent)
+            @analyzers.each do |a|
+              begin
+                a.on_leave_#{node_type}(node, parent, self)
+              rescue AnalysisError => err
+                @rescued_errors << err
+              end
+            end
+          end
+
+          RUBY
+        end
 
         def on_operation_definition(node, parent)
           object_type = @schema.root_type_for_operation(node.operation_type)
           @object_types.push(object_type)
           @path.push("#{node.operation_type}#{node.name ? " #{node.name}" : ""}")
-          call_analyzers(:on_enter_operation_definition, node, parent)
+          call_on_enter_operation_definition(node, parent)
           super
-          call_analyzers(:on_leave_operation_definition, node, parent)
+          call_on_leave_operation_definition(node, parent)
           @object_types.pop
           @path.pop
         end
@@ -81,19 +108,19 @@ module GraphQL
           on_fragment_with_type(node) do
             @path.push("fragment #{node.name}")
             @in_fragment_def = false
-            call_analyzers(:on_enter_fragment_definition, node, parent)
+            call_on_enter_fragment_definition(node, parent)
             super
             @in_fragment_def = false
-            call_analyzers(:on_leave_fragment_definition, node, parent)
+            call_on_leave_fragment_definition(node, parent)
           end
         end
 
         def on_inline_fragment(node, parent)
           on_fragment_with_type(node) do
             @path.push("...#{node.type ? " on #{node.type.name}" : ""}")
-            call_analyzers(:on_enter_inline_fragment, node, parent)
+            call_on_enter_inline_fragment(node, parent)
             super
-            call_analyzers(:on_leave_inline_fragment, node, parent)
+            call_on_leave_inline_fragment(node, parent)
           end
         end
 
@@ -114,12 +141,10 @@ module GraphQL
           @skipping = @skip_stack.last || skip?(node)
           @skip_stack << @skipping
 
-          call_analyzers(:on_enter_field, node, parent)
+          call_on_enter_field(node, parent)
           super
-
           @skipping = @skip_stack.pop
-
-          call_analyzers(:on_leave_field, node, parent)
+          call_on_leave_field(node, parent)
           @response_path.pop
           @field_definitions.pop
           @object_types.pop
@@ -129,9 +154,9 @@ module GraphQL
         def on_directive(node, parent)
           directive_defn = @schema.directives[node.name]
           @directive_definitions.push(directive_defn)
-          call_analyzers(:on_enter_directive, node, parent)
+          call_on_enter_directive(node, parent)
           super
-          call_analyzers(:on_leave_directive, node, parent)
+          call_on_leave_directive(node, parent)
           @directive_definitions.pop
         end
 
@@ -153,29 +178,23 @@ module GraphQL
 
           @argument_definitions.push(argument_defn)
           @path.push(node.name)
-          call_analyzers(:on_enter_argument, node, parent)
+          call_on_enter_argument(node, parent)
           super
-          call_analyzers(:on_leave_argument, node, parent)
+          call_on_leave_argument(node, parent)
           @argument_definitions.pop
           @path.pop
         end
 
         def on_fragment_spread(node, parent)
           @path.push("... #{node.name}")
-          call_analyzers(:on_enter_fragment_spread, node, parent)
+          call_on_enter_fragment_spread(node, parent)
           enter_fragment_spread_inline(node)
           super
           leave_fragment_spread_inline(node)
-          call_analyzers(:on_leave_fragment_spread, node, parent)
+          call_on_leave_fragment_spread(node, parent)
           @path.pop
         end
 
-        def on_abstract_node(node, parent)
-          call_analyzers(:on_enter_abstract_node, node, parent)
-          super
-          call_analyzers(:on_leave_abstract_node, node, parent)
-        end
-
         # @return [GraphQL::BaseType] The current object type
         def type_definition
           @object_types.last
@@ -226,9 +245,7 @@ module GraphQL
 
           object_types << object_type
 
-          fragment_def.selections.each do |selection|
-            visit_node(selection, fragment_def)
-          end
+          on_fragment_definition_children(fragment_def)
         end
 
         # Visit a fragment spread inline instead of visiting the definition
@@ -242,16 +259,6 @@ module GraphQL
           dir.any? && !GraphQL::Execution::DirectiveChecks.include?(dir, query)
         end
 
-        def call_analyzers(method, node, parent)
-          @analyzers.each do |analyzer|
-            begin
-              analyzer.public_send(method, node, parent, self)
-            rescue AnalysisError => err
-              @rescued_errors << err
-            end
-          end
-        end
-
         def on_fragment_with_type(node)
           object_type = if node.type
             @query.warden.get_type(node.type.name)

data/lib/graphql/analysis/ast.rb

@@ -11,16 +11,6 @@ module GraphQL
   module Analysis
     module AST
       module_function
-
-      def use(schema_class)
-        if schema_class.analysis_engine == self
-          definition_line = caller(2, 1).first
-          GraphQL::Deprecation.warn("GraphQL::Analysis::AST is now the default; remove `use GraphQL::Analysis::AST` from the schema definition (#{definition_line})")
-        else
-          schema_class.analysis_engine = self
-        end
-      end
-
       # Analyze a multiplex, and all queries within.
       # Multiplex analyzers are ran for all queries, keeping state.
       # Query analyzers are ran per query, without carrying state between queries.
@@ -31,7 +21,7 @@ module GraphQL
       def analyze_multiplex(multiplex, analyzers)
         multiplex_analyzers = analyzers.map { |analyzer| analyzer.new(multiplex) }
 
-        multiplex.trace("analyze_multiplex", { multiplex: multiplex }) do
+        multiplex.current_trace.analyze_multiplex(multiplex: multiplex) do
           query_results = multiplex.queries.map do |query|
             if query.valid?
               analyze_query(
@@ -58,7 +48,7 @@ module GraphQL
       # @param analyzers [Array<GraphQL::Analysis::AST::Analyzer>]
       # @return [Array<Any>] Results from those analyzers
       def analyze_query(query, analyzers, multiplex_analyzers: [])
-        query.trace("analyze_query", { query: query }) do
+        query.current_trace.analyze_query(query: query) do
           query_analyzers = analyzers
             .map { |analyzer| analyzer.new(query) }
             .select { |analyzer| analyzer.analyze? }

data/lib/graphql/analysis.rb

@@ -1,9 +1,2 @@
 # frozen_string_literal: true
 require "graphql/analysis/ast"
-require "graphql/analysis/max_query_complexity"
-require "graphql/analysis/max_query_depth"
-require "graphql/analysis/query_complexity"
-require "graphql/analysis/query_depth"
-require "graphql/analysis/reducer_state"
-require "graphql/analysis/analyze_query"
-require "graphql/analysis/field_usage"

data/lib/graphql/backtrace/table.rb

@@ -83,7 +83,7 @@ module GraphQL
           value = if top && @override_value
             @override_value
           else
-            value_at(@context.query.context.namespace(:interpreter)[:runtime], context_entry.path)
+            value_at(@context.query.context.namespace(:interpreter_runtime)[:runtime], context_entry.path)
           end
           rows << [
             "#{context_entry.ast_node ? context_entry.ast_node.position.join(":") : ""}",
@@ -97,24 +97,6 @@ module GraphQL
           else
             rows
           end
-        when GraphQL::Query::Context::FieldResolutionContext
-          ctx = context_entry
-          field_name = "#{ctx.irep_node.owner_type.name}.#{ctx.field.name}"
-          position = "#{ctx.ast_node.line}:#{ctx.ast_node.col}"
-          field_alias = ctx.ast_node.alias
-          object = ctx.object
-          if object.is_a?(GraphQL::Schema::Object)
-            object = object.object
-          end
-          rows << [
-            "#{position}",
-            "#{field_name}#{field_alias ? " as #{field_alias}" : ""}",
-            "#{object.inspect}",
-            ctx.irep_node.arguments.to_h.inspect,
-            Backtrace::InspectResult.inspect_result(top && @override_value ? @override_value : ctx.value),
-          ]
-
-          build_rows(ctx.parent, rows: rows)
         when GraphQL::Query::Context
           query = context_entry.query
           op = query.selected_operation
@@ -130,7 +112,7 @@ module GraphQL
           if object.is_a?(GraphQL::Schema::Object)
             object = object.object
           end
-          value = value_at(context_entry.namespace(:interpreter)[:runtime], [])
+          value = value_at(context_entry.namespace(:interpreter_runtime)[:runtime], [])
           rows << [
             "#{position}",
             "#{op_type}#{op_name ? " #{op_name}" : ""}",

data/lib/graphql/backtrace/trace.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+module GraphQL
+  class Backtrace
+    module Trace
+      def validate(query:, validate:)
+        if query.multiplex
+          push_query_backtrace_context(query)
+        end
+        super
+      end
+
+      def analyze_query(query:)
+        if query.multiplex # missing for stand-alone static validation
+          push_query_backtrace_context(query)
+        end
+        super
+      end
+
+      def execute_query(query:)
+        push_query_backtrace_context(query)
+        super
+      end
+
+      def execute_query_lazy(query:, multiplex:)
+        query ||= multiplex.queries.first
+        push_query_backtrace_context(query)
+        super
+      end
+
+      def execute_field(field:, query:, ast_node:, arguments:, object:)
+        push_field_backtrace_context(field, query, ast_node, arguments, object)
+        super
+      end
+
+      def execute_field_lazy(field:, query:, ast_node:, arguments:, object:)
+        push_field_backtrace_context(field, query, ast_node, arguments, object)
+        super
+      end
+
+      def execute_multiplex(multiplex:)
+        super
+      rescue StandardError => err
+        # This is an unhandled error from execution,
+        # Re-raise it with a GraphQL trace.
+        multiplex_context = multiplex.context
+        potential_context = multiplex_context[:last_graphql_backtrace_context]
+
+        if potential_context.is_a?(GraphQL::Query::Context) ||
+            potential_context.is_a?(Backtrace::Frame)
+          raise TracedError.new(err, potential_context)
+        else
+          raise
+        end
+      ensure
+        multiplex_context = multiplex.context
+        multiplex_context.delete(:graphql_backtrace_contexts)
+        multiplex_context.delete(:last_graphql_backtrace_context)
+      end
+
+      private
+
+      def push_query_backtrace_context(query)
+        push_data = query
+        multiplex = query.multiplex
+        push_key = []
+        push_storage = multiplex.context[:graphql_backtrace_contexts] ||= {}
+        push_storage[push_key] = push_data
+        multiplex.context[:last_graphql_backtrace_context] = push_data
+      end
+
+      def push_field_backtrace_context(field, query, ast_node, arguments, object)
+        multiplex = query.multiplex
+        push_key = query.context[:current_path]
+        push_storage = multiplex.context[:graphql_backtrace_contexts]
+        parent_frame = push_storage[push_key[0..-2]]
+
+        if parent_frame.is_a?(GraphQL::Query)
+          parent_frame = parent_frame.context
+        end
+
+        push_data = Frame.new(
+          query: query,
+          path: push_key,
+          ast_node: ast_node,
+          field: field,
+          object: object,
+          arguments: arguments,
+          parent_frame: parent_frame,
+        )
+
+        push_storage[push_key] = push_data
+        multiplex.context[:last_graphql_backtrace_context] = push_data
+      end
+    end
+  end
+end

data/lib/graphql/backtrace/tracer.rb

@@ -23,9 +23,9 @@ module GraphQL
             push_data = multiplex.queries.first
           end
         when "execute_field", "execute_field_lazy"
-          query = metadata[:query] || raise(ArgumentError, "Add `legacy: true` to use GraphQL::Backtrace without the interpreter runtime.")
+          query = metadata[:query]
           multiplex = query.multiplex
-          push_key = metadata[:path]
+          push_key = query.context[:current_path]
           parent_frame = multiplex.context[:graphql_backtrace_contexts][push_key[0..-2]]
 
           if parent_frame.is_a?(GraphQL::Query)
@@ -62,7 +62,6 @@ module GraphQL
             potential_context = multiplex_context[:last_graphql_backtrace_context]
 
             if potential_context.is_a?(GraphQL::Query::Context) ||
-                potential_context.is_a?(GraphQL::Query::Context::FieldResolutionContext) ||
                 potential_context.is_a?(Backtrace::Frame)
               raise TracedError.new(err, potential_context)
             else

data/lib/graphql/backtrace.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 require "graphql/backtrace/inspect_result"
-require "graphql/backtrace/legacy_tracer"
 require "graphql/backtrace/table"
 require "graphql/backtrace/traced_error"
 require "graphql/backtrace/tracer"
+require "graphql/backtrace/trace"
 module GraphQL
   # Wrap unhandled errors with {TracedError}.
   #
@@ -23,13 +23,8 @@ module GraphQL
 
     def_delegators :to_a, :each, :[]
 
-    def self.use(schema_defn, legacy: false)
-      tracer = if legacy
-        self::LegacyTracer
-      else
-        self::Tracer
-      end
-      schema_defn.tracer(tracer)
+    def self.use(schema_defn)
+      schema_defn.trace_with(self::Trace)
     end
 
     def initialize(context, value: nil)
@@ -60,5 +55,9 @@ module GraphQL
         @parent_frame = parent_frame
       end
     end
+
+    class DefaultBacktraceTrace < GraphQL::Tracing::Trace
+      include GraphQL::Backtrace::Trace
+    end
   end
 end

data/lib/graphql/dataloader/null_dataloader.rb

@@ -11,7 +11,9 @@ module GraphQL
       # executed sychronously.
       def run; end
       def run_isolated; yield; end
-      def yield; end
+      def yield
+        raise GraphQL::Error, "GraphQL::Dataloader is not running -- add `use GraphQL::Dataloader` to your schema to use Dataloader sources."
+      end
 
       def append_job
         yield

data/lib/graphql/dataloader/source.rb

@@ -86,6 +86,15 @@ module GraphQL
         !@pending_keys.empty?
       end
 
+      # Add these key-value pairs to this source's cache
+      # (future loads will use these merged values).
+      # @param results [Hash<Object => Object>] key-value pairs to cache in this source
+      # @return [void]
+      def merge(results)
+        @results.merge!(results)
+        nil
+      end
+
       # Called by {GraphQL::Dataloader} to resolve and pending requests to this source.
       # @api private
       # @return [void]

data/lib/graphql/dataloader.rb

@@ -289,7 +289,10 @@ module GraphQL
       fiber_locals = {}
 
       Thread.current.keys.each do |fiber_var_key|
-        fiber_locals[fiber_var_key] = Thread.current[fiber_var_key]
+        # This variable should be fresh in each new fiber
+        if fiber_var_key != :__graphql_runtime_info
+          fiber_locals[fiber_var_key] = Thread.current[fiber_var_key]
+        end
       end
 
       if @nonblocking

data/lib/graphql/dig.rb

@@ -2,7 +2,7 @@
 module GraphQL
   module Dig
     # implemented using the old activesupport #dig instead of the ruby built-in
-    # so we can use some of the magic in Schema::InputObject and Query::Arguments
+    # so we can use some of the magic in Schema::InputObject and Interpreter::Arguments
     # to handle stringified/symbolized keys.
     #
     # @param args [Array<[String, Symbol>] Retrieves the value object corresponding to the each key objects repeatedly