graphql 1.11.10 → 1.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: edd6b4edae07b6c52383810319efb2cdd19a8f818639dda22c79308620330274
-  data.tar.gz: '09869b52706e249e6e41282e9e06243547db556d42410c4e2d0cb9abf00d7e3f'
+  metadata.gz: 433f1170eb17ab192761efcd8c27cf9efe5f952ab47b501baca270e33d6007cd
+  data.tar.gz: c56045f746385ae37ebd0f82116aad10782e9265c13e0e85e39488ef3db02c74
 SHA512:
-  metadata.gz: d5c8e1b96dea2f3ac9c8c93639e6b0c9763984c9af6ca09201ef89bfbbfd2ff61cd622417d04f5624fb6c679822d8a58c1a148c5139e1e1e51bf03eb5aaaaa4a
-  data.tar.gz: 07c12d4dd5b50d5b36a3c8e298ae663969e203ce6103c449ec0b599c5960c145b34dd9c023986c5d3cb2f0d6169b5395530bca6d07985152fb12505dc1af6036
+  metadata.gz: 6d580c78b6b659602067fcfd3043eff7ef2b20da1d50c1ca2b234614d864e1a232cb65e7456cfdf85764523f30bd5232823ea19b4664208aef875cc68e2e5fc9
+  data.tar.gz: 172bc16fadfeee1f022646498dd2ce359bd885fb96ddbeeab50f7583d27811501e583194dd582a7cf47d63545c2fe00c4fa4625b6b247155f537ff4a6de60ac1

data/lib/generators/graphql/install_generator.rb

@@ -43,9 +43,6 @@ module Graphql
     # post "/graphql", to: "graphql#execute"
     # ```
     #
-    # Accept a `--relay` option which adds
-    # The root `node(id: ID!)` field.
-    #
     # Accept a `--batch` option which adds `GraphQL::Batch` setup.
     #
     # Use `--no-graphiql` to skip `graphiql-rails` installation.
@@ -79,8 +76,8 @@ module Graphql
 
       class_option :relay,
         type: :boolean,
-        default: false,
-        desc: "Include GraphQL::Relay installation"
+        default: true,
+        desc: "Include installation of Relay conventions (nodes, connections, edges)"
 
       class_option :batch,
         type: :boolean,
@@ -164,7 +161,10 @@ if Rails.env.development?
 RUBY
             end
           end
+        end
 
+        if options[:relay]
+          generate("graphql:relay")
         end
 
         if gemfile_modified?

data/lib/generators/graphql/relay_generator.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+require 'rails/generators/base'
+require_relative 'core'
+
+module Graphql
+  module Generators
+    class RelayGenerator < Rails::Generators::Base
+      include Core
+
+      desc "Add base types and fields for Relay-style nodes and connections"
+      source_root File.expand_path('../templates', __FILE__)
+
+      def install_relay
+        # Add Node, `node(id:)`, and `nodes(ids:)`
+        template("node_type.erb", "#{options[:directory]}/types/node_type.rb")
+        in_root do
+          fields = "    # Add `node(id: ID!) and `nodes(ids: [ID!]!)`\n    include GraphQL::Types::Relay::HasNodeField\n    include GraphQL::Types::Relay::HasNodesField\n\n"
+          inject_into_file "#{options[:directory]}/types/query_type.rb", fields, after: /class .*QueryType\s*<\s*[^\s]+?\n/m, force: false
+        end
+
+        # Add connections and edges
+        template("base_connection.erb", "#{options[:directory]}/types/base_connection.rb")
+        template("base_edge.erb", "#{options[:directory]}/types/base_edge.rb")
+        connectionable_type_files = {
+          "#{options[:directory]}/types/base_object.rb" => /class .*BaseObject\s*<\s*[^\s]+?\n/m,
+          "#{options[:directory]}/types/base_union.rb" =>  /class .*BaseUnion\s*<\s*[^\s]+?\n/m,
+          "#{options[:directory]}/types/base_interface.rb" => /include GraphQL::Schema::Interface\n/m,
+        }
+        in_root do
+          connectionable_type_files.each do |type_class_file, sentinel|
+            inject_into_file type_class_file, "    connection_type_class(Types::BaseConnection)\n", after: sentinel, force: false
+            inject_into_file type_class_file, "    edge_type_class(Types::BaseEdge)\n", after: sentinel, force: false
+          end
+        end
+
+        # Add object ID hooks & connection plugin
+        schema_code = <<-RUBY
+
+  # Relay-style Object Identification:
+
+  # Return a string UUID for `object`
+  def self.id_from_object(object, type_definition, query_ctx)
+    # Here's a simple implementation which:
+    # - joins the type name & object.id
+    # - encodes it with base64:
+    # GraphQL::Schema::UniqueWithinType.encode(type_definition.name, object.id)
+  end
+
+  # Given a string UUID, find the object
+  def self.object_from_id(id, query_ctx)
+    # For example, to decode the UUIDs generated above:
+    # type_name, item_id = GraphQL::Schema::UniqueWithinType.decode(id)
+    #
+    # Then, based on `type_name` and `id`
+    # find an object in your application
+    # ...
+  end
+RUBY
+        inject_into_file schema_file_path, schema_code, before: /^end\n/m, force: false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+<% module_namespacing_when_supported do -%>
+module Types
+  class BaseConnection < Types::BaseObject
+    # add `nodes` and `pageInfo` fields, as well as `edge_type(...)` and `node_nullable(...)` overrides
+    include GraphQL::Types::Relay::ConnectionBehaviors
+  end
+end
+<% end -%>

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

@@ -0,0 +1,8 @@
+<% module_namespacing_when_supported do -%>
+module Types
+  class BaseEdge < Types::BaseObject
+    # add `node` and `cursor` fields, as well as `node_type(...)` override
+    include GraphQL::Types::Relay::EdgeBehaviors
+  end
+end
+<% end -%>

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

@@ -0,0 +1,9 @@
+<% module_namespacing_when_supported do -%>
+module Types
+  module NodeType
+    include Types::BaseInterface
+    # Add the `id` field
+    include GraphQL::Types::Relay::NodeBehaviors
+  end
+end
+<% end -%>

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

@@ -1,7 +1,7 @@
 <% module_namespacing_when_supported do -%>
 module Types
   class <%= type_ruby_name.split('::')[-1] %> < Types::BaseObject
-<% if options.node %>    implements GraphQL::Relay::Node.interface
+<% if options.node %>    implements GraphQL::Types::Relay::Node
 <% end %><% normalized_fields.each do |f| %>    <%= f.to_ruby %>
 <% end %>  end
 end

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

@@ -10,8 +10,6 @@ module Types
     def test_field
       "Hello World!"
     end
-<% if options[:relay] %>
-    field :node, field: GraphQL::Relay::Node.field
-<% end %>  end
+  end
 end
 <% end -%>

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

@@ -1,42 +1,15 @@
 <% module_namespacing_when_supported do -%>
 class <%= schema_name %> < GraphQL::Schema
   query(Types::QueryType)
-
-  # Opt in to the new runtime (default in future graphql-ruby versions)
-  use GraphQL::Execution::Interpreter
-  use GraphQL::Analysis::AST
-
-  # Add built-in connections for pagination
-  use GraphQL::Pagination::Connections
-<% if options[:relay] %>
-  # Relay Object Identification:
-
-  # Return a string UUID for `object`
-  def self.id_from_object(object, type_definition, query_ctx)
-    # Here's a simple implementation which:
-    # - joins the type name & object.id
-    # - encodes it with base64:
-    # GraphQL::Schema::UniqueWithinType.encode(type_definition.name, object.id)
-  end
-
-  # Given a string UUID, find the object
-  def self.object_from_id(id, query_ctx)
-    # For example, to decode the UUIDs generated above:
-    # type_name, item_id = GraphQL::Schema::UniqueWithinType.decode(id)
-    #
-    # Then, based on `type_name` and `id`
-    # find an object in your application
-    # ...
-  end
-
-  # Object Resolution
-  def self.resolve_type(type, obj, ctx)
+<% if options[:batch] %>
+  # GraphQL::Batch setup:
+  use GraphQL::Batch
+<% end %>
+  # Union and Interface Resolution
+  def self.resolve_type(abstract_type, obj, ctx)
     # TODO: Implement this function
-    # to return the correct type for `obj`
+    # to return the correct object type for `obj`
     raise(GraphQL::RequiredImplementationMissingError)
   end
-<% end %><% if options[:batch] %>
-  # GraphQL::Batch setup:
-  use GraphQL::Batch
-<% end %>end
+end
 <% end -%>

data/lib/graphql/analysis/analyze_query.rb

@@ -3,6 +3,11 @@ module GraphQL
   module Analysis
     module_function
 
+    def use(schema_class)
+      schema = schema_class.is_a?(Class) ? schema_class : schema_class.target
+      schema.analysis_engine = self
+    end
+
     # @return [void]
     def analyze_multiplex(multiplex, analyzers)
       multiplex.trace("analyze_multiplex", { multiplex: multiplex }) do
@@ -38,6 +43,8 @@ module GraphQL
     # @param analyzers [Array<#call>] Objects that respond to `#call(memo, visit_type, irep_node)`
     # @return [Array<Any>] Results from those analyzers
     def analyze_query(query, analyzers, multiplex_states: [])
+      warn "Legacy analysis will be removed in GraphQL-Ruby 2.0, please upgrade to AST Analysis: https://graphql-ruby.org/queries/ast_analysis.html (schema: #{query.schema})"
+
       query.trace("analyze_query", { query: query }) do
         analyzers_to_run = analyzers.select do |analyzer|
           if analyzer.respond_to?(:analyze?)

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

@@ -19,6 +19,7 @@ module GraphQL
           @field_definitions = []
           @argument_definitions = []
           @directive_definitions = []
+          @rescued_errors = []
           @query = query
           @schema = query.schema
           @response_path = []
@@ -32,6 +33,9 @@ module GraphQL
         # @return [Array<GraphQL::ObjectType>] Types whose scope we've entered
         attr_reader :object_types
 
+        # @return [Array<GraphQL::AnalysisError]
+        attr_reader :rescued_errors
+
         def visit
           return unless @document
           super
@@ -239,7 +243,11 @@ module GraphQL
 
         def call_analyzers(method, node, parent)
           @analyzers.each do |analyzer|
-            analyzer.public_send(method, node, parent, self)
+            begin
+              analyzer.public_send(method, node, parent, self)
+            rescue AnalysisError => err
+              @rescued_errors << err
+            end
           end
         end
 

data/lib/graphql/analysis/ast.rb

@@ -13,7 +13,12 @@ module GraphQL
       module_function
 
       def use(schema_class)
-        schema_class.analysis_engine = GraphQL::Analysis::AST
+        if schema_class.analysis_engine == self
+          definition_line = caller(2, 1).first
+          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.
@@ -67,7 +72,11 @@ module GraphQL
 
             visitor.visit
 
-            query_analyzers.map(&:result)
+            if visitor.rescued_errors.any?
+              visitor.rescued_errors
+            else
+              query_analyzers.map(&:result)
+            end
           else
             []
           end

data/lib/graphql/backtrace/legacy_tracer.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+module GraphQL
+  class Backtrace
+    module LegacyTracer
+      module_function
+
+      # Implement the {GraphQL::Tracing} API.
+      def trace(key, metadata)
+        case key
+        when "lex", "parse"
+          # No context here, don't have a query yet
+          nil
+        when "execute_multiplex", "analyze_multiplex"
+          # No query context yet
+          nil
+        when "validate", "analyze_query", "execute_query", "execute_query_lazy"
+          query = metadata[:query] || metadata[:queries].first
+          push_data = query
+          multiplex = query.multiplex
+        when "execute_field", "execute_field_lazy"
+          # The interpreter passes `query:`, legacy passes `context:`
+          context = metadata[:context] || ((q = metadata[:query]) && q.context)
+          push_data = context
+          multiplex = context.query.multiplex
+        else
+          # Custom key, no backtrace data for this
+          nil
+        end
+
+        if push_data
+          multiplex.context[:last_graphql_backtrace_context] = push_data
+        end
+
+        if key == "execute_multiplex"
+          begin
+            yield
+          rescue StandardError => err
+            # This is an unhandled error from execution,
+            # Re-raise it with a GraphQL trace.
+            potential_context = metadata[:multiplex].context[:last_graphql_backtrace_context]
+
+            if potential_context.is_a?(GraphQL::Query::Context) || potential_context.is_a?(GraphQL::Query::Context::FieldResolutionContext)
+              raise TracedError.new(err, potential_context)
+            else
+              raise
+            end
+          ensure
+            metadata[:multiplex].context.delete(:last_graphql_backtrace_context)
+          end
+        else
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/graphql/backtrace/table.rb

@@ -79,6 +79,25 @@ module GraphQL
       # @return [Array] 5 items for a backtrace table (not `key`)
       def build_rows(context_entry, rows:, top: false)
         case context_entry
+        when Backtrace::Frame
+          field_alias = context_entry.ast_node.respond_to?(:alias) && context_entry.ast_node.alias
+          value = if top && @override_value
+            @override_value
+          else
+            @context.query.context.namespace(:interpreter)[:runtime].value_at(context_entry.path)
+          end
+          rows << [
+            "#{context_entry.ast_node ? context_entry.ast_node.position.join(":") : ""}",
+            "#{context_entry.field.path}#{field_alias ? " as #{field_alias}" : ""}",
+            "#{context_entry.object.object.inspect}",
+            context_entry.arguments.to_h.inspect,
+            Backtrace::InspectResult.inspect_result(value),
+          ]
+          if (parent = context_entry.parent_frame)
+            build_rows(parent, rows: rows)
+          else
+            rows
+          end
         when GraphQL::Query::Context::FieldResolutionContext
           ctx = context_entry
           field_name = "#{ctx.irep_node.owner_type.name}.#{ctx.field.name}"
@@ -112,15 +131,16 @@ module GraphQL
           if object.is_a?(GraphQL::Schema::Object)
             object = object.object
           end
+          value = context_entry.namespace(:interpreter)[:runtime].value_at([])
           rows << [
             "#{position}",
             "#{op_type}#{op_name ? " #{op_name}" : ""}",
             "#{object.inspect}",
             query.variables.to_h.inspect,
-            Backtrace::InspectResult.inspect_result(query.context.value),
+            Backtrace::InspectResult.inspect_result(value),
           ]
         else
-          raise "Unexpected get_rows subject #{context_entry.inspect}"
+          raise "Unexpected get_rows subject #{context_entry.class} (#{context_entry.inspect})"
         end
       end
     end

data/lib/graphql/backtrace/tracer.rb

@@ -1,46 +1,77 @@
 # frozen_string_literal: true
 module GraphQL
   class Backtrace
+    # TODO this is not fiber-friendly
     module Tracer
       module_function
 
       # Implement the {GraphQL::Tracing} API.
       def trace(key, metadata)
-        push_data = case key
+        case key
         when "lex", "parse"
           # No context here, don't have a query yet
           nil
         when "execute_multiplex", "analyze_multiplex"
-          metadata[:multiplex].queries
+          # No query context yet
+          nil
         when "validate", "analyze_query", "execute_query", "execute_query_lazy"
-          metadata[:query] || metadata[:queries]
+          query = metadata[:query] || metadata[:queries].first
+          push_key = []
+          push_data = query
+          multiplex = query.multiplex
         when "execute_field", "execute_field_lazy"
-          # The interpreter passes `query:`, legacy passes `context:`
-          metadata[:context] || ((q = metadata[:query]) && q.context)
+          query = metadata[:query] || raise(ArgumentError, "Add `legacy: true` to use GraphQL::Backtrace without the interpreter runtime.")
+          context = query.context
+          multiplex = query.multiplex
+          push_key = metadata[:path].reject { |i| i.is_a?(Integer) }
+          parent_frame = multiplex.context[:graphql_backtrace_contexts][push_key[0..-2]]
+          if parent_frame.nil?
+            p push_key
+            binding.pry
+          end
+          if parent_frame.is_a?(GraphQL::Query)
+            parent_frame = parent_frame.context
+          end
+
+          push_data = Frame.new(
+            query: query,
+            path: push_key,
+            ast_node: metadata[:ast_node],
+            field: metadata[:field],
+            object: metadata[:object],
+            arguments: metadata[:arguments],
+            parent_frame: parent_frame,
+          )
         else
           # Custom key, no backtrace data for this
           nil
         end
 
         if push_data
-          Thread.current[:last_graphql_backtrace_context] = push_data
+          multiplex.context[:graphql_backtrace_contexts][push_key] = push_data
+          multiplex.context[:last_graphql_backtrace_context] = push_data
         end
 
         if key == "execute_multiplex"
+          multiplex_context = metadata[:multiplex].context
+          multiplex_context[:graphql_backtrace_contexts] = {}
           begin
             yield
           rescue StandardError => err
             # This is an unhandled error from execution,
             # Re-raise it with a GraphQL trace.
-            potential_context = Thread.current[:last_graphql_backtrace_context]
+            potential_context = multiplex_context[:last_graphql_backtrace_context]
 
-            if potential_context.is_a?(GraphQL::Query::Context) || potential_context.is_a?(GraphQL::Query::Context::FieldResolutionContext)
+            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
               raise
             end
           ensure
-            Thread.current[:last_graphql_backtrace_context] = nil
+            multiplex_context.delete(:graphql_backtrace_contexts)
+            multiplex_context.delete(:last_graphql_backtrace_context)
           end
         else
           yield

data/lib/graphql/backtrace.rb

@@ -1,5 +1,6 @@
 # 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"
@@ -9,13 +10,12 @@ module GraphQL
   # {TracedError} provides a GraphQL backtrace with arguments and return values.
   # The underlying error is available as {TracedError#cause}.
   #
-  # WARNING: {.enable} is not threadsafe because {GraphQL::Tracing.install} is not threadsafe.
-  #
   # @example toggling backtrace annotation
-  #   # to enable:
-  #   GraphQL::Backtrace.enable
-  #   # later, to disable:
-  #   GraphQL::Backtrace.disable
+  #   class MySchema < GraphQL::Schema
+  #     if Rails.env.development? || Rails.env.test?
+  #       use GraphQL::Backtrace
+  #     end
+  #   end
   #
   class Backtrace
     include Enumerable
@@ -23,19 +23,13 @@ module GraphQL
 
     def_delegators :to_a, :each, :[]
 
-    def self.enable
-      warn("GraphQL::Backtrace.enable is deprecated, add `use GraphQL::Backtrace` to your schema definition instead.")
-      GraphQL::Tracing.install(Backtrace::Tracer)
-      nil
-    end
-
-    def self.disable
-      GraphQL::Tracing.uninstall(Backtrace::Tracer)
-      nil
-    end
-
-    def self.use(schema_defn)
-      schema_defn.tracer(self::Tracer)
+    def self.use(schema_defn, legacy: false)
+      tracer = if legacy
+        self::LegacyTracer
+      else
+        self::Tracer
+      end
+      schema_defn.tracer(tracer)
     end
 
     def initialize(context, value: nil)
@@ -51,5 +45,20 @@ module GraphQL
     def to_a
       @table.to_backtrace
     end
+
+    # Used for internal bookkeeping
+    # @api private
+    class Frame
+      attr_reader :path, :query, :ast_node, :object, :field, :arguments, :parent_frame
+      def initialize(path:, query:, ast_node:, object:, field:, arguments:, parent_frame:)
+        @path = path
+        @query = query
+        @ast_node = ast_node
+        @field = field
+        @object = object
+        @arguments = arguments
+        @parent_frame = parent_frame
+      end
+    end
   end
 end

data/lib/graphql/backwards_compatibility.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 module GraphQL
   # Helpers for migrating in a backwards-compatible way
+  # Remove this in GraphQL-Ruby 2.0, when all users of it will be gone.
   # @api private
   module BackwardsCompatibility
     module_function

data/lib/graphql/compatibility/execution_specification.rb

@@ -32,6 +32,7 @@ module GraphQL
       # @param execution_strategy [<#new, #execute>] An execution strategy class
       # @return [Class<Minitest::Test>] A test suite for this execution strategy
       def self.build_suite(execution_strategy)
+        warn "#{self} will be removed from GraphQL-Ruby 2.0. There is no replacement, please open an issue on GitHub if you need support."
         Class.new(Minitest::Test) do
           class << self
             attr_accessor :counter_schema, :specification_schema

data/lib/graphql/compatibility/lazy_execution_specification.rb

@@ -7,6 +7,8 @@ module GraphQL
       # @param execution_strategy [<#new, #execute>] An execution strategy class
       # @return [Class<Minitest::Test>] A test suite for this execution strategy
       def self.build_suite(execution_strategy)
+        warn "#{self} will be removed from GraphQL-Ruby 2.0. There is no replacement, please open an issue on GitHub if you need support."
+
         Class.new(Minitest::Test) do
           class << self
             attr_accessor :lazy_schema

data/lib/graphql/compatibility/query_parser_specification.rb

@@ -11,6 +11,8 @@ module GraphQL
       # @yieldreturn [GraphQL::Language::Nodes::Document]
       # @return [Class<Minitest::Test>] A test suite for this parse function
       def self.build_suite(&block)
+        warn "#{self} will be removed from GraphQL-Ruby 2.0. There is no replacement, please open an issue on GitHub if you need support."
+
         Class.new(Minitest::Test) do
           include QueryAssertions
           include ParseErrorSpecification

data/lib/graphql/compatibility/schema_parser_specification.rb

@@ -8,6 +8,8 @@ module GraphQL
       # @yieldreturn [GraphQL::Language::Nodes::Document]
       # @return [Class<Minitest::Test>] A test suite for this parse function
       def self.build_suite(&block)
+        warn "#{self} will be removed from GraphQL-Ruby 2.0. There is no replacement, please open an issue on GitHub if you need support."
+
         Class.new(Minitest::Test) do
           @@parse_fn = block
 

data/lib/graphql/dataloader/null_dataloader.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Dataloader
+    # The default implementation of dataloading -- all no-ops.
+    #
+    # The Dataloader interface isn't public, but it enables
+    # simple internal code while adding the option to add Dataloader.
+    class NullDataloader < Dataloader
+      def enqueue
+        yield
+      end
+
+      # These are all no-ops because code was
+      # executed sychronously.
+      def run; end
+      def yield; end
+      def yielded?; false; end
+    end
+  end
+end

data/lib/graphql/dataloader/request.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+module GraphQL
+  class Dataloader
+    # @see Source#request which returns an instance of this
+    class Request
+      def initialize(source, key)
+        @source = source
+        @key = key
+      end
+
+      # Call this method to cause the current Fiber to wait for the results of this request.
+      #
+      # @return [Object] the object loaded for `key`
+      def load
+        if @source.results.key?(@key)
+          @source.results[@key]
+        else
+          @source.sync
+          @source.results[@key]
+        end
+      end
+    end
+  end
+end