graphql 1.8.7 → 1.9.0

data/lib/graphql/schema/input_object.rb

@@ -5,12 +5,17 @@ module GraphQL
       extend GraphQL::Schema::Member::AcceptsDefinition
       extend Forwardable
       extend GraphQL::Schema::Member::HasArguments
+      include GraphQL::Dig
 
-      def initialize(values, context:, defaults_used:)
+      def initialize(values = nil, ruby_kwargs: nil, context:, defaults_used:)
         @context = context
-        @arguments = self.class.arguments_class.new(values, context: context, defaults_used: defaults_used)
-        # Symbolized, underscored hash:
-        @ruby_style_hash = @arguments.to_kwargs
+        if ruby_kwargs
+          @ruby_style_hash = ruby_kwargs
+        else
+          @arguments = self.class.arguments_class.new(values, context: context, defaults_used: defaults_used)
+          # Symbolized, underscored hash:
+          @ruby_style_hash = @arguments.to_kwargs
+        end
         # Apply prepares, not great to have it duplicated here.
         self.class.arguments.each do |name, arg_defn|
           ruby_kwargs_key = arg_defn.keyword
@@ -56,13 +61,15 @@ module GraphQL
       def [](key)
         if @ruby_style_hash.key?(key)
           @ruby_style_hash[key]
-        else
+        elsif @arguments
           @arguments[key]
+        else
+          nil
         end
       end
 
       def key?(key)
-        @ruby_style_hash.key?(key) || @arguments.key?(key)
+        @ruby_style_hash.key?(key) || (@arguments && @arguments.key?(key))
       end
 
       # A copy of the Ruby-style hash
@@ -78,8 +85,9 @@ module GraphQL
           argument_defn = super
           # Add a method access
           arg_name = argument_defn.graphql_definition.name
-          define_method(Member::BuildType.underscore(arg_name)) do
-            @arguments.public_send(arg_name)
+          method_name = Member::BuildType.underscore(arg_name).to_sym
+          define_method(method_name) do
+            @ruby_style_hash[method_name]
           end
         end
 

data/lib/graphql/schema/interface.rb

@@ -9,6 +9,7 @@ module GraphQL
         include GraphQL::Schema::Member::BaseDSLMethods
         include GraphQL::Schema::Member::TypeSystemHelpers
         include GraphQL::Schema::Member::HasFields
+        include GraphQL::Schema::Member::HasPath
         include GraphQL::Schema::Member::RelayShortcuts
         include GraphQL::Schema::Member::Scoped
 

data/lib/graphql/schema/loader.rb

@@ -55,6 +55,27 @@ module GraphQL
           end
         end
 
+        def extract_default_value(default_value_str, input_value_ast)
+          case input_value_ast
+          when String, Integer, Float, TrueClass, FalseClass
+            input_value_ast
+          when GraphQL::Language::Nodes::Enum
+            input_value_ast.name
+          when GraphQL::Language::Nodes::NullValue
+            nil
+          when GraphQL::Language::Nodes::InputObject
+            input_value_ast.to_h
+          when Array
+            input_value_ast.map { |element| extract_default_value(default_value_str, element) }
+          else
+            raise(
+              "Encountered unexpected type when loading default value. "\
+                    "input_value_ast.class is #{input_value_ast.class} "\
+                    "default_value is #{default_value_str}"
+            )
+          end
+        end
+
         def define_type(type, type_resolver)
           case type.fetch("kind")
           when "ENUM"
@@ -119,22 +140,7 @@ module GraphQL
                 # Reach into the AST for the default value:
                 input_value_ast = dummy_query_ast.definitions.first.variables.first.default_value
 
-                case input_value_ast
-                when String, Integer, Float, TrueClass, FalseClass, Array
-                  input_value_ast
-                when GraphQL::Language::Nodes::Enum
-                  input_value_ast.name
-                when GraphQL::Language::Nodes::NullValue
-                  nil
-                when GraphQL::Language::Nodes::InputObject
-                  input_value_ast.to_h
-                else
-                  raise(
-                    "Encountered unexpected type when loading default value. "\
-                    "input_value_ast.class is #{input_value_ast.class} "\
-                    "default_value is #{default_value_str}"
-                  )
-                end
+                extract_default_value(default_value_str, input_value_ast)
               end
             end
 

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

@@ -55,6 +55,10 @@ module GraphQL
           end
         end
 
+        def introspection?
+          introspection
+        end
+
         # The mutation this type was derived from, if it was derived from a mutation
         # @return [Class]
         def mutation(mutation_class = nil)
@@ -79,9 +83,11 @@ module GraphQL
         # The default name is the Ruby constant name,
         # without any namespaces and with any `-Type` suffix removed
         def default_graphql_name
-          raise NotImplementedError, 'Anonymous class should declare a `graphql_name`' if name.nil?
+          @default_graphql_name ||= begin
+            raise NotImplementedError, 'Anonymous class should declare a `graphql_name`' if name.nil?
 
-          name.split("::").last.sub(/Type\Z/, "")
+            name.split("::").last.sub(/Type\Z/, "")
+          end
         end
 
         def visible?(context)

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

@@ -33,7 +33,7 @@ module GraphQL
               null = false
               parse_type(type_expr[0..-2], null: true)
             else
-              maybe_type = Object.const_get(type_expr)
+              maybe_type = constantize(type_expr)
               case maybe_type
               when GraphQL::BaseType
                 maybe_type
@@ -125,6 +125,38 @@ module GraphQL
           camelized
         end
 
+        # Resolves constant from string (based on Rails `ActiveSupport::Inflector.constantize`)
+        def constantize(string)
+          names = string.split('::')
+
+          # Trigger a built-in NameError exception including the ill-formed constant in the message.
+          Object.const_get(string) if names.empty?
+
+          # Remove the first blank element in case of '::ClassName' notation.
+          names.shift if names.size > 1 && names.first.empty?
+
+          names.inject(Object) do |constant, name|
+            if constant == Object
+              constant.const_get(name)
+            else
+              candidate = constant.const_get(name)
+              next candidate if constant.const_defined?(name, false)
+              next candidate unless Object.const_defined?(name)
+
+              # Go down the ancestors to check if it is owned directly. The check
+              # stops when we reach Object or the end of ancestors tree.
+              constant = constant.ancestors.inject do |const, ancestor|
+                break const    if ancestor == Object
+                break ancestor if ancestor.const_defined?(name, false)
+                const
+              end
+
+              # Owner is in Object, so raise.
+              constant.const_get(name, false)
+            end
+          end
+        end
+
         def underscore(string)
           string
             .gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2') # URLDecoder -> URL_Decoder

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

@@ -29,9 +29,13 @@ module GraphQL
 
         # @return [Hash<String => GraphQL::Schema::Argument] Arguments defined on this thing, keyed by name. Includes inherited definitions
         def arguments
-          inherited_arguments = ((self.is_a?(Class) && superclass.respond_to?(:arguments)) ? superclass.arguments : {})
+          inherited_arguments = ((self.is_a?(Class) && superclass.respond_to?(:arguments)) ? superclass.arguments : nil)
           # Local definitions override inherited ones
-          inherited_arguments.merge(own_arguments)
+          if inherited_arguments
+            inherited_arguments.merge(own_arguments)
+          else
+            own_arguments
+          end
         end
 
         # @param new_arg_class [Class] A class to use for building argument definitions

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

@@ -4,47 +4,6 @@ module GraphQL
     class Member
       # Shared code for Object and Interface
       module HasFields
-        class << self
-          # When this module is added to a class,
-          # add a place for that class's default behaviors
-          def self.extended(child_class)
-            add_default_resolve_module(child_class)
-            super
-          end
-
-          # Create a module which will have instance methods for implementing fields.
-          # These will be `super` methods for fields in interfaces, objects and mutations.
-          # Use an instance variable on the class instead of a constant
-          # so that module namespaces won't be an issue. (If we used constants,
-          # `child_class::DefaultResolve` might find a constant from an included module.)
-          def add_default_resolve_module(child_class)
-            if child_class.instance_variable_get(:@_default_resolve)
-              # This can happen when an object implements an interface,
-              # since that interface has the `included` hook above.
-              return
-            end
-
-            default_resolve_module = Module.new
-            child_class.instance_variable_set(:@_default_resolve, default_resolve_module)
-            child_class.include(default_resolve_module)
-          end
-        end
-
-        # When this is included into interfaces,
-        # add a place for default field behaviors
-        def included(child_class)
-          HasFields.add_default_resolve_module(child_class)
-          # Also, prepare a place for default field implementations
-          super
-        end
-
-        # When a subclass of objects are created,
-        # add a place for that subclass's default field behaviors
-        def inherited(child_class)
-          HasFields.add_default_resolve_module(child_class)
-          super
-        end
-
         # Add a field to this object or interface with the given definition
         # @see {GraphQL::Schema::Field#initialize} for method signature
         # @return [void]
@@ -66,16 +25,24 @@ module GraphQL
           all_fields
         end
 
+        def get_field(field_name)
+          if (f = own_fields[field_name])
+            f
+          else
+            for ancestor in ancestors
+              if ancestor.respond_to?(:own_fields) && f = ancestor.own_fields[field_name]
+                return f
+              end
+            end
+            nil
+          end
+        end
+
         # Register this field with the class, overriding a previous one if needed.
-        # Also, add a parent method for resolving this field.
         # @param field_defn [GraphQL::Schema::Field]
         # @return [void]
         def add_field(field_defn)
           own_fields[field_defn.name] = field_defn
-          if !method_defined?(field_defn.method_sym)
-            # Only add the super method if there isn't one already.
-            add_super_method(field_defn.name.inspect, field_defn.method_sym)
-          end
           nil
         end
 
@@ -94,36 +61,17 @@ module GraphQL
         end
 
         def global_id_field(field_name)
-          field field_name, "ID", null: false, resolve: GraphQL::Relay::GlobalIdResolve.new(type: self)
+          id_resolver = GraphQL::Relay::GlobalIdResolve.new(type: self)
+          field field_name, "ID", null: false
+          define_method(field_name) do
+            id_resolver.call(object, {}, context)
+          end
         end
 
         # @return [Array<GraphQL::Schema::Field>] Fields defined on this class _specifically_, not parent classes
         def own_fields
           @own_fields ||= {}
         end
-
-        private
-        # Find the magic module for holding super methods,
-        # and add a field named `method_name` for implementing the field
-        # called `field_name`.
-        # It will be the `super` method if the method is overwritten in the class definition.
-        def add_super_method(field_key, method_name)
-          default_resolve_module = @_default_resolve
-          if default_resolve_module.nil?
-            # This should have been set up in one of the inherited or included hooks above,
-            # if it wasn't, it's because those hooks weren't called because `super` wasn't present.
-            raise <<-ERR
-Uh oh! #{self} doesn't have a default resolve module. This probably means that an `inherited` hook didn't call super.
-Check `inherited` on #{self}'s superclasses.
-ERR
-          end
-          default_resolve_module.module_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{method_name}(**args)
-              field_inst = self.class.fields[#{field_key}] || raise(%|Failed to find field #{field_key} for \#{self.class} among \#{self.class.fields.keys}|)
-              field_inst.resolve_field_method(self, args, context)
-            end
-          RUBY
-        end
       end
     end
   end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      module HasPath
+        # @return [String] A description of this member's place in the GraphQL schema
+        def path
+          path_str = if self.respond_to?(:graphql_name)
+            self.graphql_name
+          elsif self.class.respond_to?(:graphql_name)
+            # Instances of resolvers
+            self.class.graphql_name
+          end
+
+          if self.respond_to?(:owner) && owner.respond_to?(:path)
+            path_str = "#{owner.path}.#{path_str}"
+          end
+
+          path_str
+        end
+      end
+    end
+  end
+end

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

@@ -91,7 +91,7 @@ module GraphQL
                   # For lists with nil, we need another nil check here
                   nil
                 else
-                  concrete_type = case @inner_return_type
+                  concrete_type_or_lazy = case @inner_return_type
                   when GraphQL::UnionType, GraphQL::InterfaceType
                     ctx.query.resolve_type(@inner_return_type, inner_obj)
                   when GraphQL::ObjectType
@@ -100,12 +100,15 @@ module GraphQL
                     raise "unexpected proxying type #{@inner_return_type} for #{inner_obj} at #{ctx.owner_type}.#{ctx.field.name}"
                   end
 
-                  if concrete_type && (object_class = concrete_type.metadata[:type_class])
-                    # use the query-level context here, since it won't be field-specific anyways
-                    query_ctx = ctx.query.context
-                    object_class.authorized_new(inner_obj, query_ctx)
-                  else
-                    inner_obj
+                  # .resolve_type may have returned a lazy
+                  ctx.schema.after_lazy(concrete_type_or_lazy) do |concrete_type|
+                    if concrete_type && (object_class = concrete_type.metadata[:type_class])
+                      # use the query-level context here, since it won't be field-specific anyways
+                      query_ctx = ctx.query.context
+                      object_class.authorized_new(inner_obj, query_ctx)
+                    else
+                      inner_obj
+                    end
                   end
                 end
               end

data/lib/graphql/schema/member.rb

@@ -3,6 +3,7 @@ require 'graphql/schema/member/accepts_definition'
 require 'graphql/schema/member/base_dsl_methods'
 require 'graphql/schema/member/cached_graphql_definition'
 require 'graphql/schema/member/graphql_type_names'
+require 'graphql/schema/member/has_path'
 require 'graphql/schema/member/relay_shortcuts'
 require 'graphql/schema/member/scoped'
 require 'graphql/schema/member/type_system_helpers'
@@ -22,6 +23,7 @@ module GraphQL
       extend TypeSystemHelpers
       extend Scoped
       extend RelayShortcuts
+      extend HasPath
     end
   end
 end

data/lib/graphql/schema/mutation.rb

@@ -60,71 +60,29 @@ module GraphQL
     #
     class Mutation < GraphQL::Schema::Resolver
       extend GraphQL::Schema::Member::HasFields
+      extend GraphQL::Schema::Resolver::HasPayloadType
 
       class << self
         # Override this method to handle legacy-style usages of `MyMutation.field`
         def field(*args, &block)
-          if args.none?
+          if args.empty?
             raise ArgumentError, "#{name}.field is used for adding fields to this mutation. Use `mutation: #{name}` to attach this mutation instead."
           else
             super
           end
         end
 
-        # Call this method to get the derived return type of the mutation,
-        # or use it as a configuration method to assign a return type
-        # instead of generating one.
-        # @param new_payload_type [Class, nil] If a type definition class is provided, it will be used as the return type of the mutation field
-        # @return [Class] The object type which this mutation returns.
-        def payload_type(new_payload_type = nil)
-          if new_payload_type
-            @payload_type = new_payload_type
-          end
-          @payload_type ||= generate_payload_type
-        end
-
-        alias :type :payload_type
-        alias :type_expr :payload_type
-
-        def field_class(new_class = nil)
-          if new_class
-            @field_class = new_class
-          else
-            @field_class || find_inherited_method(:field_class, GraphQL::Schema::Field)
-          end
-        end
-
-        # An object class to use for deriving return types
-        # @param new_class [Class, nil] Defaults to {GraphQL::Schema::Object}
-        # @return [Class]
-        def object_class(new_class = nil)
-          if new_class
-            @object_class = new_class
-          end
-          @object_class || (superclass.respond_to?(:object_class) ? superclass.object_class : GraphQL::Schema::Object)
-        end
-
         def visible?(context)
           true
         end
 
         private
 
-        # Build a subclass of {.object_class} based on `self`.
-        # This value will be cached as `{.payload_type}`.
-        # Override this hook to customize return type generation.
+        # Override this to attach self as `mutation`
         def generate_payload_type
-          mutation_name = graphql_name
-          mutation_fields = fields
-          mutation_class = self
-          Class.new(object_class) do
-            graphql_name("#{mutation_name}Payload")
-            description("Autogenerated return type of #{mutation_name}")
-            mutation(mutation_class)
-            mutation_fields.each do |name, f|
-              field(name, field: f)
-            end
-          end
+          payload_class = super
+          payload_class.mutation(self)
+          payload_class
         end
       end
     end

data/lib/graphql/schema/non_null.rb

@@ -24,10 +24,14 @@ module GraphQL
       def list?
         @of_type.list?
       end
-      
+
       def to_type_signature
         "#{@of_type.to_type_signature}!"
       end
+
+      def inspect
+        "#<#{self.class.name} @of_type=#{@of_type.inspect}>"
+      end
     end
   end
 end

data/lib/graphql/schema/object.rb

@@ -35,19 +35,33 @@ module GraphQL
         # @return [GraphQL::Schema::Object, GraphQL::Execution::Lazy]
         # @raise [GraphQL::UnauthorizedError] if the user-provided hook returns `false`
         def authorized_new(object, context)
-          context.schema.after_lazy(authorized?(object, context)) do |is_authorized|
+          auth_val = begin
+            authorized?(object, context)
+          # rescue GraphQL::UnauthorizedError => err
+          #   context.schema.unauthorized_object(err)
+          end
+
+          context.schema.after_lazy(auth_val) do |is_authorized|
             if is_authorized
               self.new(object, context)
             else
               # It failed the authorization check, so go to the schema's authorized object hook
               err = GraphQL::UnauthorizedError.new(object: object, type: self, context: context)
               # If a new value was returned, wrap that instead of the original value
-              new_obj = context.schema.unauthorized_object(err)
-              if new_obj
-                self.new(new_obj, context)
+              begin
+                new_obj = context.schema.unauthorized_object(err)
+                if new_obj
+                  self.new(new_obj, context)
+                else
+                  nil
+                end
+              # rescue GraphQL::ExecutionError => err
+              #   err
               end
             end
           end
+        # rescue GraphQL::ExecutionError => err
+        #   err
         end
       end
 

data/lib/graphql/schema/printer.rb

@@ -89,7 +89,7 @@ module GraphQL
       end
 
       def print_type(type)
-        node = @document_from_schema.build_object_type_node(type)
+        node = @document_from_schema.build_type_definition_node(type)
         print(node)
       end
 

data/lib/graphql/schema/relay_classic_mutation.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require "graphql/types/string"
 
 module GraphQL
   class Schema
@@ -25,19 +26,51 @@ module GraphQL
       # Relay classic default:
       null(true)
 
-      # Override {GraphQL::Schema::Mutation#resolve_mutation} to
+      # Override {GraphQL::Schema::Resolver#resolve_with_support} to
       # delete `client_mutation_id` from the kwargs.
-      def resolve_mutation(**kwargs)
-        # This is handled by Relay::Mutation::Resolve, a bit hacky, but here we are.
-        kwargs.delete(:client_mutation_id)
-        if kwargs.any?
-          resolve(**kwargs)
+      def resolve_with_support(**inputs)
+        # Without the interpreter, the inputs are unwrapped by an instrumenter.
+        # But when using the interpreter, no instrumenters are applied.
+        if context.interpreter?
+          input = inputs[:input].to_h
+          # Transfer these from the top-level hash to the
+          # shortcutted `input:` object
+          self.class.extras.each do |ext|
+            input[ext] = inputs[ext]
+          end
         else
-          resolve
+          input = inputs
+        end
+
+        if input
+          # This is handled by Relay::Mutation::Resolve, a bit hacky, but here we are.
+          input_kwargs = input.to_h
+          client_mutation_id = input_kwargs.delete(:client_mutation_id)
+        else
+          # Relay Classic Mutations with no `argument`s
+          # don't require `input:`
+          input_kwargs = {}
+        end
+
+        return_value = if input_kwargs.any?
+          super(input_kwargs)
+        else
+          super()
         end
-      end
 
-      resolve_method(:resolve_mutation)
+        # Again, this is done by an instrumenter when using non-interpreter execution.
+        if context.interpreter?
+          context.schema.after_lazy(return_value) do |return_hash|
+            # It might be an error
+            if return_hash.is_a?(Hash)
+              return_hash[:client_mutation_id] = client_mutation_id
+            end
+            return_hash
+          end
+        else
+          return_value
+        end
+      end
 
       class << self
         # The base class for generated input object types

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Resolver
+      # Adds `field(...)` helper to resolvers so that they can
+      # generate payload types.
+      #
+      # Or, an already-defined one can be attached with `payload_type(...)`.
+      module HasPayloadType
+        # Call this method to get the derived return type of the mutation,
+        # or use it as a configuration method to assign a return type
+        # instead of generating one.
+        # @param new_payload_type [Class, nil] If a type definition class is provided, it will be used as the return type of the mutation field
+        # @return [Class] The object type which this mutation returns.
+        def payload_type(new_payload_type = nil)
+          if new_payload_type
+            @payload_type = new_payload_type
+          end
+          @payload_type ||= generate_payload_type
+        end
+
+        alias :type :payload_type
+        alias :type_expr :payload_type
+
+        def field_class(new_class = nil)
+          if new_class
+            @field_class = new_class
+          else
+            @field_class || find_inherited_method(:field_class, GraphQL::Schema::Field)
+          end
+        end
+
+        # An object class to use for deriving return types
+        # @param new_class [Class, nil] Defaults to {GraphQL::Schema::Object}
+        # @return [Class]
+        def object_class(new_class = nil)
+          if new_class
+            @object_class = new_class
+          end
+          @object_class || (superclass.respond_to?(:object_class) ? superclass.object_class : GraphQL::Schema::Object)
+        end
+
+        private
+
+        # Build a subclass of {.object_class} based on `self`.
+        # This value will be cached as `{.payload_type}`.
+        # Override this hook to customize return type generation.
+        def generate_payload_type
+          resolver_name = graphql_name
+          resolver_fields = fields
+          Class.new(object_class) do
+            graphql_name("#{resolver_name}Payload")
+            description("Autogenerated return type of #{resolver_name}")
+            resolver_fields.each do |name, f|
+              # Reattach the already-defined field here
+              # (The field's `.owner` will still point to the mutation, not the object type, I think)
+              add_field(f)
+            end
+          end
+        end
+      end
+    end
+  end
+end