graphql 1.8.0 → 1.12.12

data/lib/graphql/argument.rb

@@ -1,45 +1,16 @@
 # frozen_string_literal: true
 module GraphQL
-  # Used for defined arguments ({Field}, {InputObjectType})
-  #
-  # {#name} must be a String.
-  #
-  # @example defining an argument for a field
-  #   GraphQL::Field.define do
-  #     # ...
-  #     argument :favoriteFood, types.String, "Favorite thing to eat", default_value: "pizza"
-  #   end
-  #
-  # @example defining an argument for an {InputObjectType}
-  #   GraphQL::InputObjectType.define do
-  #     argument :newName, !types.String
-  #   end
-  #
-  # @example defining an argument with a `prepare` function
-  #   GraphQL::Field.define do
-  #     argument :userId, types.ID, prepare: ->(userId) do
-  #       User.find_by(id: userId)
-  #     end
-  #   end
-  #
-  # @example returning an {ExecutionError} from a `prepare` function
-  #   GraphQL::Field.define do
-  #     argument :date do
-  #       type !types.String
-  #       prepare ->(date) do
-  #         return GraphQL::ExecutionError.new("Invalid date format") unless DateValidator.valid?(date)
-  #         Time.zone.parse(date)
-  #       end
-  #     end
-  #   end
-
+  # @api deprecated
   class Argument
     include GraphQL::Define::InstanceDefinable
-    accepts_definitions :name, :type, :description, :default_value, :as, :prepare
-    attr_accessor :type, :description, :default_value, :name, :as
+    accepts_definitions :name, :type, :description, :default_value, :as, :prepare, :method_access, :deprecation_reason
+    attr_reader :default_value
+    attr_accessor :description, :name, :as, :deprecation_reason
     attr_accessor :ast_node
+    attr_accessor :method_access
+    alias :graphql_name :name
 
-    ensure_defined(:name, :description, :default_value, :type=, :type, :as, :expose_as, :prepare)
+    ensure_defined(:name, :description, :default_value, :type=, :type, :as, :expose_as, :prepare, :method_access, :deprecation_reason)
 
     # @api private
     module DefaultPrepare
@@ -58,13 +29,18 @@ module GraphQL
       !!@has_default_value
     end
 
+    def method_access?
+      # Treat unset as true -- only `false` should override
+      @method_access != false
+    end
+
     def default_value=(new_default_value)
       if new_default_value == NO_DEFAULT_VALUE
         @has_default_value = false
         @default_value = nil
       else
         @has_default_value = true
-        @default_value = new_default_value
+        @default_value = GraphQL::Argument.deep_stringify(new_default_value)
       end
     end
 
@@ -87,6 +63,11 @@ module GraphQL
       @expose_as ||= (@as || @name).to_s
     end
 
+    # Backport this to support legacy-style directives
+    def keyword
+      @keyword ||= GraphQL::Schema::Member::BuildType.underscore(expose_as).to_sym
+    end
+
     # @param value [Object] The incoming value from variables or query string literal
     # @param ctx [GraphQL::Query::Context]
     # @return [Object] The prepared `value` for this argument or `value` itself if no `prepare` function exists.
@@ -100,6 +81,10 @@ module GraphQL
       @prepare_proc = BackwardsCompatibility.wrap_arity(prepare_proc, from: 1, to: 2, name: "Argument#prepare(value, ctx)")
     end
 
+    def type_class
+      metadata[:type_class]
+    end
+
     NO_DEFAULT_VALUE = Object.new
     # @api private
     def self.from_dsl(name, type_or_argument = nil, description = nil, default_value: NO_DEFAULT_VALUE, as: nil, prepare: DefaultPrepare, **kwargs, &block)
@@ -121,9 +106,25 @@ module GraphQL
       end
 
       if type_or_argument.is_a?(GraphQL::Argument)
-        type_or_argument.redefine(kwargs, &block)
+        type_or_argument.redefine(**kwargs, &block)
+      else
+        GraphQL::Argument.define(**kwargs, &block)
+      end
+    end
+
+    # @api private
+    def self.deep_stringify(val)
+      case val
+      when Array
+        val.map { |v| deep_stringify(v) }
+      when Hash
+        new_val = {}
+        val.each do |k, v|
+          new_val[k.to_s] = deep_stringify(v)
+        end
+        new_val
       else
-        GraphQL::Argument.define(kwargs, &block)
+        val
       end
     end
   end

data/lib/graphql/authorization.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+module GraphQL
+  module Authorization
+    class InaccessibleFieldsError < GraphQL::AnalysisError
+      # @return [Array<Schema::Field, GraphQL::Field>] Fields that failed `.accessible?` checks
+      attr_reader :fields
+
+      # @return [GraphQL::Query::Context] The current query's context
+      attr_reader :context
+
+      # @return [Array<GraphQL::InternalRepresentation::Node>] The visited nodes that failed `.accessible?` checks
+      # @see {#fields} for the Field definitions
+      attr_reader :irep_nodes
+
+      def initialize(fields:, irep_nodes:, context:)
+        @fields = fields
+        @irep_nodes = irep_nodes
+        @context = context
+        super("Some fields in this query are not accessible: #{fields.map(&:graphql_name).join(", ")}")
+      end
+    end
+
+    # @deprecated authorization at query runtime is generally a better idea.
+    module Analyzer
+      module_function
+      def initial_value(query)
+        {
+          schema: query.schema,
+          context: query.context,
+          inaccessible_nodes: [],
+        }
+      end
+
+      def call(memo, visit_type, irep_node)
+        if visit_type == :enter
+          field = irep_node.definition
+          if field
+            schema = memo[:schema]
+            ctx = memo[:context]
+            next_field_accessible = schema.accessible?(field, ctx)
+            if !next_field_accessible
+              memo[:inaccessible_nodes] << irep_node
+            else
+              arg_accessible = true
+              irep_node.arguments.argument_values.each do |name, arg_value|
+                arg_accessible = schema.accessible?(arg_value.definition, ctx)
+                if !arg_accessible
+                  memo[:inaccessible_nodes] << irep_node
+                  break
+                end
+              end
+              if arg_accessible
+                return_type = field.type.unwrap
+                next_type_accessible = schema.accessible?(return_type, ctx)
+                if !next_type_accessible
+                  memo[:inaccessible_nodes] << irep_node
+                end
+              end
+            end
+          end
+        end
+        memo
+      end
+
+      def final_value(memo)
+        nodes = memo[:inaccessible_nodes]
+        if nodes.any?
+          fields = nodes.map do |node|
+            field_inst = node.definition
+            # Get the "source of truth" for this field
+            field_inst.metadata[:type_class] || field_inst
+          end
+          context = memo[:context]
+          err = InaccessibleFieldsError.new(fields: fields, irep_nodes: nodes, context: context)
+          context.schema.inaccessible_fields(err)
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/graphql/backtrace/inspect_result.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../backtrace.rb
 module GraphQL
   class Backtrace
     module InspectResult

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

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../backtrace.rb
 module GraphQL
   class Backtrace
     # A class for turning a context into a human-readable table or array
@@ -79,15 +78,38 @@ 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
+            value_at(@context.query.context.namespace(:interpreter)[:runtime], 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}"
           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}" : ""}",
-            "#{ctx.object.inspect}",
+            "#{object.inspect}",
             ctx.irep_node.arguments.to_h.inspect,
             Backtrace::InspectResult.inspect_result(top && @override_value ? @override_value : ctx.value),
           ]
@@ -104,16 +126,33 @@ module GraphQL
             position = "?:?"
           end
           op_name = query.selected_operation_name
+          object = query.root_value
+          if object.is_a?(GraphQL::Schema::Object)
+            object = object.object
+          end
+          value = value_at(context_entry.namespace(:interpreter)[:runtime], [])
           rows << [
             "#{position}",
             "#{op_type}#{op_name ? " #{op_name}" : ""}",
-            "#{query.root_value.inspect}",
+            "#{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
+
+      def value_at(runtime, path)
+        response = runtime.response
+        path.each do |key|
+          if response && (response = response[key])
+            next
+          else
+            break
+          end
         end
+        response
       end
     end
   end

data/lib/graphql/backtrace/traced_error.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../backtrace.rb
 module GraphQL
   class Backtrace
     # When {Backtrace} is enabled, raised errors are wrapped with {TracedError}.

data/lib/graphql/backtrace/tracer.rb

@@ -1,45 +1,73 @@
 # 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"
-          metadata[:context]
+          query = metadata[:query] || raise(ArgumentError, "Add `legacy: true` to use GraphQL::Backtrace without the interpreter runtime.")
+          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.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
+        if push_data && multiplex
+          push_storage = multiplex.context[:graphql_backtrace_contexts] ||= {}
+          push_storage[push_key] = push_data
+          multiplex.context[:last_graphql_backtrace_context] = push_data
         end
 
         if key == "execute_multiplex"
+          multiplex_context = metadata[:multiplex].context
           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-compatibile way
+  # 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
@@ -21,7 +22,7 @@ module GraphQL
         backtrace = caller(0, 20)
         # Find the first line in the trace that isn't library internals:
         user_line = backtrace.find {|l| l !~ /lib\/graphql/ }
-        warn(message + "\n" + user_line + "\n")
+        GraphQL::Deprecation.warn(message + "\n" + user_line + "\n")
         wrapper = last ? LastArgumentsWrapper : FirstArgumentsWrapper
         wrapper.new(callable, from)
       else

data/lib/graphql/base_type.rb

@@ -35,7 +35,7 @@ module GraphQL
     end
 
     # @return [String] the name of this type, must be unique within a Schema
-    attr_accessor :name
+    attr_reader :name
     # Future-compatible alias
     # @see {GraphQL::SchemaMember}
     alias :graphql_name :name
@@ -43,6 +43,10 @@ module GraphQL
     # @see {GraphQL::SchemaMember}
     alias :graphql_definition :itself
 
+    def type_class
+      metadata[:type_class]
+    end
+
     def name=(name)
       GraphQL::NameValidator.validate!(name)
       @name = name
@@ -114,6 +118,7 @@ module GraphQL
     end
 
     alias :inspect :to_s
+    alias :to_type_signature :to_s
 
     def valid_isolated_input?(value)
       valid_input?(value, GraphQL::Query::NullContext)
@@ -166,7 +171,7 @@ module GraphQL
     end
 
     def coerce_result(value, ctx)
-      raise NotImplementedError
+      raise GraphQL::RequiredImplementationMissingError
     end
 
     # Types with fields may override this
@@ -186,7 +191,7 @@ module GraphQL
         resolve_related_type(type_arg.call)
       when String
         # Get a constant by this name
-        Object.const_get(type_arg)
+        resolve_related_type(Object.const_get(type_arg))
       else
         if type_arg.respond_to?(:graphql_definition)
           type_arg.graphql_definition
@@ -219,7 +224,7 @@ module GraphQL
     private
 
     def warn_deprecated_coerce(alt_method_name)
-      warn("Coercing without a context is deprecated; use `#{alt_method_name}` if you don't want context-awareness")
+      GraphQL::Deprecation.warn("Coercing without a context is deprecated; use `#{alt_method_name}` if you don't want context-awareness")
     end
   end
 end

data/lib/graphql/boolean_type.rb

@@ -1,9 +1,2 @@
 # frozen_string_literal: true
-GraphQL::BOOLEAN_TYPE = GraphQL::ScalarType.define do
-  name "Boolean"
-  description "Represents `true` or `false` values."
-
-  coerce_input ->(value, _ctx) { (value == true || value == false) ? value : nil }
-  coerce_result ->(value, _ctx) { !!value }
-  default_scalar true
-end
+GraphQL::BOOLEAN_TYPE = GraphQL::Types::Boolean.graphql_definition

data/lib/graphql/coercion_error.rb

@@ -1,5 +1,13 @@
 # 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
   end
 end

data/lib/graphql/compatibility/execution_specification/specification_schema.rb

@@ -43,14 +43,13 @@ module GraphQL
             @storage = storage
           end
 
-          def each
-            @storage.each { |i| yield(i) }
+          def each(&block)
+            @storage.each(&block)
           end
         end
 
         module TestMiddleware
-          # TODO: Once deprecated `next_middleware` argument becomes unsupported, add `&` to the argument
-          def self.call(parent_type, parent_object, field_definition, field_args, query_context, next_middleware)
+          def self.call(parent_type, parent_object, field_definition, field_args, query_context, &next_middleware)
             query_context[:middleware_log] && query_context[:middleware_log] << field_definition.name
             next_middleware.call
           end

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)
+        GraphQL::Deprecation.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/lazy_schema.rb

@@ -32,7 +32,8 @@ module GraphQL
                 @context[:pushes] << @context[:lazy_pushes]
                 @context[:lazy_pushes] = []
               end
-              self
+              # Something that _behaves_ like this object, but isn't registered lazy
+              OpenStruct.new(value: @value)
             end
           end
         end
@@ -87,7 +88,7 @@ module GraphQL
             end
 
             connection :pushes, lazy_push_type.connection_type do
-              argument :values, types[types.Int]
+              argument :values, types[types.Int], method_access: false
               resolve ->(o, a, c) {
                 LazyPushCollection.new(c, a[:values])
               }

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)
+        GraphQL::Deprecation.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