graphql 2.0.0 → 2.0.3

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

@@ -8,7 +8,15 @@ module GraphQL
           if new_edge_type_class
             @edge_type_class = new_edge_type_class
           else
-            @edge_type_class || find_inherited_value(:edge_type_class, Types::Relay::BaseEdge)
+            # Don't call `ancestor.edge_type_class`
+            # because we don't want a fallback from any ancestors --
+            # only apply the fallback if _no_ ancestor has a configured value!
+            for ancestor in self.ancestors
+              if ancestor.respond_to?(:configured_edge_type_class, true) && (etc = ancestor.configured_edge_type_class)
+                return etc
+              end
+            end
+            Types::Relay::BaseEdge
           end
         end
 
@@ -16,7 +24,15 @@ module GraphQL
           if new_connection_type_class
             @connection_type_class = new_connection_type_class
           else
-            @connection_type_class || find_inherited_value(:connection_type_class, Types::Relay::BaseConnection)
+            # Don't call `ancestor.connection_type_class`
+            # because we don't want a fallback from any ancestors --
+            # only apply the fallback if _no_ ancestor has a configured value!
+            for ancestor in self.ancestors
+              if ancestor.respond_to?(:configured_connection_type_class, true) && (ctc = ancestor.configured_connection_type_class)
+                return ctc
+              end
+            end
+            Types::Relay::BaseConnection
           end
         end
 
@@ -41,6 +57,16 @@ module GraphQL
             end
           end
         end
+
+        protected
+
+        def configured_connection_type_class
+          @connection_type_class
+        end
+
+        def configured_edge_type_class
+          @edge_type_class
+        end
       end
     end
   end

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

@@ -10,9 +10,9 @@ module GraphQL
 
         def validate_input(val, ctx)
           if val.nil?
-            GraphQL::Query::InputValidationResult.new
+            Query::InputValidationResult::VALID
           else
-            validate_non_null_input(val, ctx)
+            validate_non_null_input(val, ctx) || Query::InputValidationResult::VALID
           end
         end
 

data/lib/graphql/schema/object.rb

@@ -51,12 +51,12 @@ module GraphQL
           trace_payload = { context: context, type: self, object: object, path: context[:current_path] }
 
           maybe_lazy_auth_val = context.query.trace("authorized", trace_payload) do
-            context.query.with_error_handling do
-              begin
-                authorized?(object, context)
-              rescue GraphQL::UnauthorizedError => err
-                context.schema.unauthorized_object(err)
-              end
+            begin
+              authorized?(object, context)
+            rescue GraphQL::UnauthorizedError => err
+              context.schema.unauthorized_object(err)
+            rescue StandardError => err
+              context.query.handle_or_reraise(err)
             end
           end
 
@@ -98,9 +98,14 @@ module GraphQL
       class << self
         # Set up a type-specific invalid null error to use when this object's non-null fields wrongly return `nil`.
         # It should help with debugging and bug tracker integrations.
-        def inherited(child_class)
-          child_class.const_set(:InvalidNullError, GraphQL::InvalidNullError.subclass_for(child_class))
-          super
+        def const_missing(name)
+          if name == :InvalidNullError
+            custom_err_class = GraphQL::InvalidNullError.subclass_for(self)
+            const_set(:InvalidNullError, custom_err_class)
+            custom_err_class
+          else
+            super
+          end
         end
 
         def kind

data/lib/graphql/schema/relay_classic_mutation.rb

@@ -70,11 +70,32 @@ module GraphQL
       end
 
       class << self
+        def dummy
+          @dummy ||= begin
+            d = Class.new(GraphQL::Schema::Resolver)
+            d.argument_class(self.argument_class)
+            # TODO make this lazier?
+            d.argument(:input, input_type, description: "Parameters for #{self.graphql_name}")
+            d
+          end
+        end
+
+        def field_arguments(context = GraphQL::Query::NullContext)
+          dummy.arguments(context)
+        end
+
+        def get_field_argument(name, context = GraphQL::Query::NullContext)
+          dummy.get_argument(name, context)
+        end
+
+        def own_field_arguments
+          dummy.own_arguments
+        end
 
         # Also apply this argument to the input type:
-        def argument(*args, **kwargs, &block)
+        def argument(*args, own_argument: false, **kwargs, &block)
           it = input_type # make sure any inherited arguments are already added to it
-          arg = super
+          arg = super(*args, **kwargs, &block)
 
           # This definition might be overriding something inherited;
           # if it is, remove the inherited definition so it's not confused at runtime as having multiple definitions
@@ -114,15 +135,6 @@ module GraphQL
           @input_type ||= generate_input_type
         end
 
-        # Extend {Schema::Mutation.field_options} to add the `input` argument
-        def field_options
-          sig = super
-          # Arguments were added at the root, but they should be nested
-          sig[:arguments].clear
-          sig[:arguments][:input] = { type: input_type, required: true, description: "Parameters for #{graphql_name}" }
-          sig
-        end
-
         private
 
         # Generate the input type for the `input:` argument
@@ -130,11 +142,17 @@ module GraphQL
         # @return [Class] a subclass of {.input_object_class}
         def generate_input_type
           mutation_args = all_argument_definitions
-          mutation_name = graphql_name
           mutation_class = self
           Class.new(input_object_class) do
-            graphql_name("#{mutation_name}Input")
-            description("Autogenerated input type of #{mutation_name}")
+            class << self
+              def default_graphql_name
+                "#{self.mutation.graphql_name}Input"
+              end
+
+              def description(new_desc = nil)
+                super || "Autogenerated input type of #{self.mutation.graphql_name}"
+              end
+            end
             mutation(mutation_class)
             # these might be inherited:
             mutation_args.each do |arg|

data/lib/graphql/schema/resolver/has_payload_type.rb

@@ -20,7 +20,17 @@ module GraphQL
           @payload_type ||= generate_payload_type
         end
 
-        alias :type :payload_type
+        def type(new_type = nil, null: nil)
+          if new_type
+            payload_type(new_type)
+            if !null.nil?
+              self.null(null)
+            end
+          else
+            super()
+          end
+        end
+
         alias :type_expr :payload_type
 
         def field_class(new_class = nil)

data/lib/graphql/schema/resolver.rb

@@ -15,8 +15,6 @@ module GraphQL
     #
     # A resolver's configuration may be overridden with other keywords in the `field(...)` call.
     #
-    # See the {.field_options} to see how a Resolver becomes a set of field configuration options.
-    #
     # @see {GraphQL::Schema::Mutation} for a concrete subclass of `Resolver`.
     # @see {GraphQL::Function} `Resolver` is a replacement for `GraphQL::Function`
     class Resolver
@@ -210,6 +208,18 @@ module GraphQL
       end
 
       class << self
+        def field_arguments(context = GraphQL::Query::NullContext)
+          arguments(context)
+        end
+
+        def get_field_argument(name, context = GraphQL::Query::NullContext)
+          get_argument(name, context)
+        end
+
+        def own_field_arguments
+          own_arguments
+        end
+
         # Default `:resolve` set below.
         # @return [Symbol] The method to call on instances of this object to resolve the field
         def resolve_method(new_method = nil)
@@ -242,6 +252,14 @@ module GraphQL
           @null.nil? ? (superclass.respond_to?(:null) ? superclass.null : true) : @null
         end
 
+        def resolver_method(new_method_name = nil)
+          if new_method_name
+            @resolver_method = new_method_name
+          else
+            @resolver_method || :resolve_with_support
+          end
+        end
+
         # Call this method to get the return type of the field,
         # or use it as a configuration method to assign a return type
         # instead of generating one.
@@ -257,8 +275,8 @@ module GraphQL
             @type_expr = new_type
             @null = null
           else
-            if @type_expr
-              GraphQL::Schema::Member::BuildType.parse_type(@type_expr, null: @null)
+            if type_expr
+              GraphQL::Schema::Member::BuildType.parse_type(type_expr, null: self.null)
             elsif superclass.respond_to?(:type)
               superclass.type
             else
@@ -307,47 +325,7 @@ module GraphQL
 
         # @return [Boolean] `true` if this resolver or a superclass has an assigned `max_page_size`
         def has_max_page_size?
-          defined?(@max_page_size) || (superclass.respond_to?(:has_max_page_size?) && superclass.has_max_page_size?)
-        end
-
-        def field_options
-
-          all_args = {}
-          all_argument_definitions.each do |arg|
-            if (prev_entry = all_args[arg.graphql_name])
-              if prev_entry.is_a?(Array)
-                prev_entry << arg
-              else
-                all_args[arg.graphql_name] = [prev_entry, arg]
-              end
-            else
-              all_args[arg.graphql_name] = arg
-            end
-          end
-
-          field_opts = {
-            type: type_expr,
-            description: description,
-            extras: extras,
-            resolver_method: :resolve_with_support,
-            resolver_class: self,
-            arguments: all_args,
-            null: null,
-            complexity: complexity,
-            broadcastable: broadcastable?,
-          }
-
-          # If there aren't any, then the returned array is `[].freeze`,
-          # but passing that along breaks some user code.
-          if (exts = extensions).any?
-            field_opts[:extensions] = exts
-          end
-
-          if has_max_page_size?
-            field_opts[:max_page_size] = max_page_size
-          end
-
-          field_opts
+          (!!defined?(@max_page_size)) || (superclass.respond_to?(:has_max_page_size?) && superclass.has_max_page_size?)
         end
 
         # A non-normalized type configuration, without `null` applied

data/lib/graphql/schema/scalar.rb

@@ -41,13 +41,12 @@ module GraphQL
         end
 
         def validate_non_null_input(value, ctx)
-          result = Query::InputValidationResult.new
           coerced_result = begin
-            ctx.query.with_error_handling do
-              coerce_input(value, ctx)
-            end
+            coerce_input(value, ctx)
           rescue GraphQL::CoercionError => err
             err
+          rescue StandardError => err
+            ctx.query.handle_or_reraise(err)
           end
 
           if coerced_result.nil?
@@ -56,11 +55,12 @@ module GraphQL
             else
               " #{GraphQL::Language.serialize(value)}"
             end
-            result.add_problem("Could not coerce value#{str_value} to #{graphql_name}")
+            Query::InputValidationResult.from_problem("Could not coerce value#{str_value} to #{graphql_name}")
           elsif coerced_result.is_a?(GraphQL::CoercionError)
-            result.add_problem(coerced_result.message, message: coerced_result.message, extensions: coerced_result.extensions)
+            Query::InputValidationResult.from_problem(coerced_result.message, message: coerced_result.message, extensions: coerced_result.extensions)
+          else
+            nil
           end
-          result
         end
       end
     end

data/lib/graphql/schema/subscription.rb

@@ -143,13 +143,6 @@ module GraphQL
       def self.topic_for(arguments:, field:, scope:)
         Subscriptions::Serialize.dump_recursive([scope, field.graphql_name, arguments])
       end
-
-      # Overriding Resolver#field_options to include subscription_scope
-      def self.field_options
-        super.merge(
-          subscription_scope: subscription_scope
-        )
-      end
     end
   end
 end

data/lib/graphql/schema/warden.rb

@@ -10,7 +10,7 @@ module GraphQL
     # should go through a warden. If you access the schema directly,
     # you may show a client something that it shouldn't be allowed to see.
     #
-    # @example Hidding private fields
+    # @example Hiding private fields
     #   private_members = -> (member, ctx) { member.metadata[:private] }
     #   result = Schema.execute(query_string, except: private_members)
     #

data/lib/graphql/schema.rb

@@ -693,7 +693,41 @@ module GraphQL
 
       def rescue_from(*err_classes, &handler_block)
         err_classes.each do |err_class|
-          error_handler.rescue_from(err_class, handler_block)
+          Execution::Errors.register_rescue_from(err_class, error_handlers[:subclass_handlers], handler_block)
+        end
+      end
+
+      NEW_HANDLER_HASH = ->(h, k) {
+        h[k] = {
+          class: k,
+          handler: nil,
+          subclass_handlers: Hash.new(&NEW_HANDLER_HASH),
+         }
+      }
+
+      def error_handlers
+        @error_handlers ||= {
+          class: nil,
+          handler: nil,
+          subclass_handlers: Hash.new(&NEW_HANDLER_HASH),
+        }
+      end
+
+      # @api private
+      def handle_or_reraise(context, err)
+        handler = Execution::Errors.find_handler_for(self, err.class)
+        if handler
+          runtime_info = context.namespace(:interpreter) || {}
+          obj = runtime_info[:current_object]
+          args = runtime_info[:current_arguments]
+          args = args && args.keyword_arguments
+          field = runtime_info[:current_field]
+          if obj.is_a?(GraphQL::Schema::Object)
+            obj = obj.object
+          end
+          handler[:handler].call(err, obj, args, context, field)
+        else
+          raise err
         end
       end
 
@@ -821,11 +855,6 @@ module GraphQL
         ctx.errors.push(parse_err)
       end
 
-      # @return [GraphQL::Execution::Errors]
-      def error_handler
-        @error_handler ||= GraphQL::Execution::Errors.new(self)
-      end
-
       def lazy_resolve(lazy_class, value_method)
         lazy_methods.set(lazy_class, value_method)
       end

data/lib/graphql/subscriptions.rb

@@ -56,17 +56,24 @@ module GraphQL
     # @param args [Hash<String, Symbol => Object]
     # @param object [Object]
     # @param scope [Symbol, String]
+    # @param context [Hash]
     # @return [void]
-    def trigger(event_name, args, object, scope: nil)
+    def trigger(event_name, args, object, scope: nil, context: {})
+      # Make something as context-like as possible, even though there isn't a current query:
+      context = @schema.context_class.new(
+        query: GraphQL::Query.new(@schema, "", validate: false),
+        object: nil,
+        values: context
+      )
       event_name = event_name.to_s
 
       # Try with the verbatim input first:
-      field = @schema.get_field(@schema.subscription, event_name)
+      field = @schema.get_field(@schema.subscription, event_name, context)
 
       if field.nil?
         # And if it wasn't found, normalize it:
         normalized_event_name = normalize_name(event_name)
-        field = @schema.get_field(@schema.subscription, normalized_event_name)
+        field = @schema.get_field(@schema.subscription, normalized_event_name, context)
         if field.nil?
           raise InvalidTriggerError, "No subscription matching trigger: #{event_name} (looked for #{@schema.subscription.graphql_name}.#{normalized_event_name})"
         end

data/lib/graphql/tracing/data_dog_tracing.rb

@@ -48,7 +48,9 @@ module GraphQL
       end
 
       def tracer
-        options.fetch(:tracer, Datadog.tracer)
+        default_tracer = defined?(Datadog::Tracing) ? Datadog::Tracing : Datadog.tracer
+
+        options.fetch(:tracer, default_tracer)
       end
 
       def analytics_available?

data/lib/graphql/types/relay/connection_behaviors.rb

@@ -148,22 +148,6 @@ module GraphQL
             obj_type.field :page_info, GraphQL::Types::Relay::PageInfo, null: false, description: "Information to aid in pagination."
           end
         end
-
-        # By default this calls through to the ConnectionWrapper's edge nodes method,
-        # but sometimes you need to override it to support the `nodes` field
-        def nodes
-          @object.edge_nodes
-        end
-
-        def edges
-          if @object.is_a?(GraphQL::Pagination::Connection)
-            @object.edges
-          else
-            context.schema.after_lazy(object.edge_nodes) do |nodes|
-              nodes.map { |n| self.class.edge_class.new(n, object) }
-            end
-          end
-        end
       end
     end
   end

data/lib/graphql/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.3
 platform: ruby
 authors:
 - Robert Mosolgo
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-09 00:00:00.000000000 Z
+date: 2022-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -366,7 +366,6 @@ files:
 - lib/graphql/query/context.rb
 - lib/graphql/query/fingerprint.rb
 - lib/graphql/query/input_validation_result.rb
-- lib/graphql/query/literal_input.rb
 - lib/graphql/query/null_context.rb
 - lib/graphql/query/result.rb
 - lib/graphql/query/validation_pipeline.rb
@@ -582,7 +581,7 @@ metadata:
   source_code_uri: https://github.com/rmosolgo/graphql-ruby
   bug_tracker_uri: https://github.com/rmosolgo/graphql-ruby/issues
   mailing_list_uri: https://tinyletter.com/graphql-ruby
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -597,8 +596,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key: 
+rubygems_version: 3.3.3
+signing_key:
 specification_version: 4
 summary: A GraphQL language and runtime for Ruby
 test_files: []

data/lib/graphql/query/literal_input.rb

@@ -1,131 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class Query
-    # Turn query string values into something useful for query execution
-    class LiteralInput
-      def self.coerce(type, ast_node, variables)
-        case ast_node
-        when nil
-          nil
-        when Language::Nodes::NullValue
-          nil
-        when Language::Nodes::VariableIdentifier
-          variables[ast_node.name]
-        else
-          case type.kind.name
-          when "SCALAR"
-            # TODO smell
-            # This gets used for plain values during subscriber.trigger
-            if variables
-              type.coerce_input(ast_node, variables.context)
-            else
-              type.coerce_isolated_input(ast_node)
-            end
-          when "ENUM"
-            # TODO smell
-            # This gets used for plain values sometimes
-            v = ast_node.is_a?(GraphQL::Language::Nodes::Enum) ? ast_node.name : ast_node
-            if variables
-              type.coerce_input(v, variables.context)
-            else
-              type.coerce_isolated_input(v)
-            end
-          when "NON_NULL"
-            LiteralInput.coerce(type.of_type, ast_node, variables)
-          when "LIST"
-            if ast_node.is_a?(Array)
-              ast_node.map { |element_ast| LiteralInput.coerce(type.of_type, element_ast, variables) }
-            else
-              [LiteralInput.coerce(type.of_type, ast_node, variables)]
-            end
-          when "INPUT_OBJECT"
-            # TODO smell: handling AST vs handling plain Ruby
-            next_args = ast_node.is_a?(Hash) ? ast_node : ast_node.arguments
-            from_arguments(next_args, type, variables)
-          else
-            raise "Invariant: unexpected type to coerce to: #{type}"
-          end
-        end
-      end
-
-      def self.from_arguments(ast_arguments, argument_owner, variables)
-        context = variables ? variables.context : nil
-        values_hash = {}
-        defaults_used = Set.new
-
-        indexed_arguments = case ast_arguments
-        when Hash
-          ast_arguments
-        when Array
-          ast_arguments.each_with_object({}) { |a, memo| memo[a.name] = a }
-        else
-          raise ArgumentError, "Unexpected ast_arguments: #{ast_arguments}"
-        end
-
-        argument_defns = argument_owner.arguments(context || GraphQL::Query::NullContext)
-        argument_defns.each do |arg_name, arg_defn|
-          ast_arg = indexed_arguments[arg_name]
-          # First, check the argument in the AST.
-          # If the value is a variable,
-          # only add a value if the variable is actually present.
-          # Otherwise, coerce the value in the AST, prepare the value and add it.
-          #
-          # TODO: since indexed_arguments can come from a plain Ruby hash,
-          # have to check for `false` or `nil` as hash values. This is getting smelly :S
-          if indexed_arguments.key?(arg_name)
-            arg_value = ast_arg.is_a?(GraphQL::Language::Nodes::Argument) ? ast_arg.value : ast_arg
-
-            value_is_a_variable = arg_value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
-
-            if (!value_is_a_variable || (value_is_a_variable && variables.key?(arg_value.name)))
-
-              value = coerce(arg_defn.type, arg_value, variables)
-              # Legacy `prepare` application
-              if arg_defn.is_a?(GraphQL::Argument)
-                value = arg_defn.prepare(value, context)
-              end
-
-              if value.is_a?(GraphQL::ExecutionError)
-                value.ast_node = ast_arg
-                raise value
-              end
-
-              values_hash[arg_name] = value
-            end
-          end
-
-          # Then, the definition for a default value.
-          # If the definition has a default value and
-          # a value wasn't provided from the AST,
-          # then add the default value.
-          if arg_defn.default_value? && !values_hash.key?(arg_name)
-            value = arg_defn.default_value
-            defaults_used << arg_name
-            # `context` isn't present when pre-calculating defaults
-            if context
-              if arg_defn.is_a?(GraphQL::Argument)
-                value = arg_defn.prepare(value, context)
-              end
-              if value.is_a?(GraphQL::ExecutionError)
-                value.ast_node = ast_arg
-                raise value
-              end
-            end
-            values_hash[arg_name] = value
-          end
-        end
-
-        # A Schema::InputObject, Schema::GraphQL::Field, Schema::Directive, logic from Interpreter::Arguments
-        ruby_kwargs = {}
-        values_hash.each do |key, value|
-          ruby_kwargs[Schema::Member::BuildType.underscore(key).to_sym] = value
-        end
-        if argument_owner.is_a?(Class) && argument_owner < GraphQL::Schema::InputObject
-          argument_owner.new(ruby_kwargs: ruby_kwargs, context: context, defaults_used: defaults_used)
-        else
-          ruby_kwargs
-        end
-      end
-    end
-  end
-end