graphql 1.8.0.pre9 → 1.8.0.pre10

data/lib/graphql/relay/mutation/instrumentation.rb

@@ -10,7 +10,7 @@ module GraphQL
         # By using an instrumention, we can apply our wrapper _last_,
         # giving users access to the original resolve function in earlier instrumentation.
         def self.instrument(type, field)
-          if field.mutation
+          if field.mutation.is_a?(GraphQL::Relay::Mutation) || (field.mutation.is_a?(Class) && field.mutation < GraphQL::Schema::RelayClassicMutation)
             new_resolve = Mutation::Resolve.new(field.mutation, field.resolve_proc)
             new_lazy_resolve = Mutation::Resolve.new(field.mutation, field.lazy_resolve_proc)
             field.redefine(resolve: new_resolve, lazy_resolve: new_lazy_resolve)

data/lib/graphql/relay/mutation/resolve.rb

@@ -10,7 +10,8 @@ module GraphQL
         def initialize(mutation, resolve)
           @mutation = mutation
           @resolve = resolve
-          @wrap_result = mutation.has_generated_return_type?
+          @wrap_result = mutation.is_a?(GraphQL::Relay::Mutation) && mutation.has_generated_return_type?
+          @class_based = mutation.is_a?(Class)
         end
 
         def call(obj, args, ctx)
@@ -44,6 +45,9 @@ module GraphQL
             end
 
             @mutation.result_class.new(client_mutation_id: args[:input][:clientMutationId], result: mutation_result)
+          elsif @class_based
+            mutation_result[:client_mutation_id] = args[:input][:client_mutation_id]
+            mutation_result
           else
             mutation_result
           end

data/lib/graphql/schema.rb

@@ -27,6 +27,8 @@ require "graphql/schema/enum"
 require "graphql/schema/field"
 require "graphql/schema/input_object"
 require "graphql/schema/interface"
+require "graphql/schema/mutation"
+require "graphql/schema/relay_classic_mutation"
 require "graphql/schema/object"
 require "graphql/schema/scalar"
 require "graphql/schema/union"
@@ -96,7 +98,9 @@ module GraphQL
       :orphan_types, :directives,
       :query_analyzers, :multiplex_analyzers, :instrumenters, :lazy_methods,
       :cursor_encoder,
-      :raise_definition_error, :introspection_namespace
+      :ast_node,
+      :raise_definition_error,
+      :introspection_namespace
 
     # Single, long-lived instance of the provided subscriptions class, if there is one.
     # @return [GraphQL::Subscriptions]

data/lib/graphql/schema/argument.rb

@@ -48,6 +48,7 @@ module GraphQL
           Member::BuildType.parse_type(@type_expr, null: @null)
         }
         argument.description = @description
+        argument.metadata[:type_class] = self
         if NO_DEFAULT != @default_value
           argument.default_value = @default_value
         end

data/lib/graphql/schema/build_from_definition.rb

@@ -107,6 +107,8 @@ module GraphQL
             directives directives.values
           end
 
+          schema.ast_node = schema_definition if schema_definition
+
           schema
         end
 
@@ -117,18 +119,26 @@ module GraphQL
         NullScalarCoerce = ->(val, _ctx) { val }
 
         def build_enum_type(enum_type_definition, type_resolver)
-          GraphQL::EnumType.define(
+          enum = GraphQL::EnumType.define(
             name: enum_type_definition.name,
             description: enum_type_definition.description,
             values: enum_type_definition.values.map do |enum_value_definition|
-              EnumType::EnumValue.define(
+              value = EnumType::EnumValue.define(
                 name: enum_value_definition.name,
                 value: enum_value_definition.name,
                 deprecation_reason: build_deprecation_reason(enum_value_definition.directives),
                 description: enum_value_definition.description,
               )
+
+              value.ast_node = enum_value_definition
+
+              value
             end
           )
+
+          enum.ast_node = enum_type_definition
+
+          enum
         end
 
         def build_deprecation_reason(directives)
@@ -148,6 +158,8 @@ module GraphQL
             coerce: NullScalarCoerce,
           )
 
+          scalar_type.ast_node = scalar_type_definition
+
           if default_resolve.respond_to?(:coerce_input)
             scalar_type = scalar_type.redefine(
               coerce_input: ->(val, ctx) { default_resolve.coerce_input(scalar_type, val, ctx) },
@@ -159,11 +171,15 @@ module GraphQL
         end
 
         def build_union_type(union_type_definition, type_resolver)
-          GraphQL::UnionType.define(
+          union = GraphQL::UnionType.define(
             name: union_type_definition.name,
             description: union_type_definition.description,
             possible_types: union_type_definition.types.map{ |type_name| type_resolver.call(type_name) },
           )
+
+          union.ast_node = union_type_definition
+
+          union
         end
 
         def build_object_type(object_type_definition, type_resolver, default_resolve:)
@@ -175,14 +191,20 @@ module GraphQL
             fields: Hash[build_fields(object_type_definition.fields, type_resolver, default_resolve: typed_resolve_fn)],
             interfaces: object_type_definition.interfaces.map{ |interface_name| type_resolver.call(interface_name) },
           )
+          type_def.ast_node = object_type_definition
+          type_def
         end
 
         def build_input_object_type(input_object_type_definition, type_resolver)
-          GraphQL::InputObjectType.define(
+          input = GraphQL::InputObjectType.define(
             name: input_object_type_definition.name,
             description: input_object_type_definition.description,
             arguments: Hash[build_input_arguments(input_object_type_definition, type_resolver)],
           )
+
+          input.ast_node = input_object_type_definition
+
+          input
         end
 
         def build_default_value(default_value)
@@ -208,25 +230,33 @@ module GraphQL
               kwargs[:default_value] = build_default_value(input_argument.default_value)
             end
 
+            argument = GraphQL::Argument.define(
+              name: input_argument.name,
+              type: type_resolver.call(input_argument.type),
+              description: input_argument.description,
+              **kwargs,
+            )
+
+            argument.ast_node = input_object_type_definition
+
             [
               input_argument.name,
-              GraphQL::Argument.define(
-                name: input_argument.name,
-                type: type_resolver.call(input_argument.type),
-                description: input_argument.description,
-                **kwargs,
-              )
+              argument
             ]
           end
         end
 
         def build_directive(directive_definition, type_resolver)
-          GraphQL::Directive.define(
+          directive = GraphQL::Directive.define(
             name: directive_definition.name,
             description: directive_definition.description,
             arguments: Hash[build_directive_arguments(directive_definition, type_resolver)],
             locations: directive_definition.locations.map(&:to_sym),
           )
+
+          directive.ast_node = directive_definition
+
+          directive
         end
 
         def build_directive_arguments(directive_definition, type_resolver)
@@ -237,24 +267,32 @@ module GraphQL
               kwargs[:default_value] = build_default_value(directive_argument.default_value)
             end
 
+            argument = GraphQL::Argument.define(
+              name: directive_argument.name,
+              type: type_resolver.call(directive_argument.type),
+              description: directive_argument.description,
+              **kwargs,
+            )
+
+            argument.ast_node = directive_argument
+
             [
               directive_argument.name,
-              GraphQL::Argument.define(
-                name: directive_argument.name,
-                type: type_resolver.call(directive_argument.type),
-                description: directive_argument.description,
-                **kwargs,
-              )
+              argument
             ]
           end
         end
 
         def build_interface_type(interface_type_definition, type_resolver)
-          GraphQL::InterfaceType.define(
+          interface = GraphQL::InterfaceType.define(
             name: interface_type_definition.name,
             description: interface_type_definition.description,
             fields: Hash[build_fields(interface_type_definition.fields, type_resolver, default_resolve: nil)],
           )
+
+          interface.ast_node = interface_type_definition
+
+          interface
         end
 
         def build_fields(field_definitions, type_resolver, default_resolve:)
@@ -273,6 +311,8 @@ module GraphQL
                 **kwargs,
               )
 
+              arg.ast_node = argument
+
               [argument.name, arg]
             end]
 
@@ -285,6 +325,8 @@ module GraphQL
               deprecation_reason: build_deprecation_reason(field_definition.directives),
             )
 
+            field.ast_node = field_definition
+
             type_name = resolve_type_name(field_definition.type)
             field.connection = type_name.end_with?("Connection")
             [field_definition.name, field]

data/lib/graphql/schema/enum.rb

@@ -53,6 +53,7 @@ module GraphQL
           values.each do |name, val|
             enum_type.add_value(val.to_graphql)
           end
+          enum_type.metadata[:type_class] = self
           enum_type
         end
 

data/lib/graphql/schema/enum_value.rb

@@ -66,6 +66,7 @@ module GraphQL
         enum_value.description = @description
         enum_value.value = @value
         enum_value.deprecation_reason = @deprecation_reason
+        enum_value.metadata[:type_class] = self
         enum_value
       end
     end

data/lib/graphql/schema/field.rb

@@ -7,6 +7,7 @@ module GraphQL
     class Field
       include GraphQL::Schema::Member::CachedGraphQLDefinition
       include GraphQL::Schema::Member::AcceptsDefinition
+      include GraphQL::Schema::Member::HasArguments
 
       # @return [String]
       attr_reader :name
@@ -14,15 +15,17 @@ module GraphQL
       # @return [String]
       attr_accessor :description
 
-      # @return [Hash{String => GraphQL::Schema::Argument}]
-      attr_reader :arguments
-
       # @return [Symbol]
       attr_reader :method
 
       # @return [Class] The type that this field belongs to
       attr_reader :owner
 
+      # @return [Class, nil] The mutation this field was derived from, if there is one
+      def mutation
+        @mutation || @mutation_class
+      end
+
       # @param name [Symbol] The underscore-cased version of this field name (will be camelized for the GraphQL API)
       # @param return_type_expr [Class, GraphQL::BaseType, Array] The return type of this field
       # @param desc [String] Field description
@@ -36,17 +39,23 @@ module GraphQL
       # @param max_page_size [Integer] For connections, the maximum number of items to return from this field
       # @param introspection [Boolean] If true, this field will be marked as `#introspection?` and the name may begin with `__`
       # @param resolve [<#call(obj, args, ctx)>] **deprecated** for compatibility with <1.8.0
-      # @param field [GraphQL::Field] **deprecated** for compatibility with <1.8.0
+      # @param field [GraphQL::Field, GraphQL::Schema::Field] **deprecated** for compatibility with <1.8.0
       # @param function [GraphQL::Function] **deprecated** for compatibility with <1.8.0
+      # @param mutation [Class] A {Schema::Mutation} class for serving this field
+      # @param mutation_class [Class] (Private) A {Schema::Mutation} which this field was derived from.
+      # @param arguments [{String=>GraphQL::Schema::Arguments}] Arguments for this field (may be added in the block, also)
       # @param camelize [Boolean] If true, the field name will be camelized when building the schema
       # @param complexity [Numeric] When provided, set the complexity for this field
-      def initialize(name, return_type_expr = nil, desc = nil, owner:, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, connection: nil, max_page_size: nil, resolve: nil, introspection: false, hash_key: nil, camelize: true, complexity: 1, extras: [], &definition_block)
+      def initialize(name, return_type_expr = nil, desc = nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, connection: nil, max_page_size: nil, resolve: nil, introspection: false, hash_key: nil, camelize: true, complexity: 1, extras: [], mutation: nil, mutation_class: nil, arguments: {}, &definition_block)
         if (field || function) && desc.nil? && return_type_expr.is_a?(String)
           # The return type should be copied from `field` or `function`, and the second positional argument is the description
           desc = return_type_expr
           return_type_expr = nil
         end
-        if !(field || function)
+        if mutation && (return_type_expr || desc || description || function || field || null || deprecation_reason || method || resolve || introspection || hash_key)
+          raise ArgumentError, "when keyword `mutation:` is present, all arguments are ignored, please remove them"
+        end
+        if !(field || function || mutation)
           if return_type_expr.nil?
             raise ArgumentError, "missing positional argument `type`"
           end
@@ -54,15 +63,19 @@ module GraphQL
             raise ArgumentError, "missing keyword argument null:"
           end
         end
-        if (field || function || resolve) && extras.any?
-          raise ArgumentError, "keyword `extras:` may only be used with method-based resolve, please remove `field:`, `function:`, or `resolve:`"
+        if (field || function || resolve || resolve) && extras.any?
+          raise ArgumentError, "keyword `extras:` may only be used with method-based resolve, please remove `field:`, `function:`, `resolve:`, or `mutation:`"
         end
         @name = name.to_s
         if description && desc
           raise ArgumentError, "Provide description as a positional argument or `description:` keyword, but not both (#{desc.inspect}, #{description.inspect})"
         end
         @description = description || desc
-        @field = field
+        if field.is_a?(GraphQL::Schema::Field)
+          @field_instance = field
+        else
+          @field = field
+        end
         @function = function
         @resolve = resolve
         @deprecation_reason = deprecation_reason
@@ -78,8 +91,11 @@ module GraphQL
         @max_page_size = max_page_size
         @introspection = introspection
         @extras = extras
-        @arguments = {}
         @camelize = camelize
+        @mutation = mutation
+        @mutation_class = mutation_class
+        # Override the default from HasArguments
+        @own_arguments = arguments
         @owner = owner
 
         if definition_block
@@ -87,13 +103,6 @@ module GraphQL
         end
       end
 
-      # This is the `argument(...)` DSL for class-based field definitons
-      def argument(*args, **kwargs, &block)
-        kwargs[:owner] = self
-        arg_defn = self.class.argument_class.new(*args, **kwargs, &block)
-        arguments[arg_defn.name] = arg_defn
-      end
-
       def description(text = nil)
         if text
           @description = text
@@ -123,6 +132,14 @@ module GraphQL
 
       # @return [GraphQL::Field]
       def to_graphql
+        # this field was previously defined and passed here, so delegate to it
+        if @field_instance
+          return @field_instance.to_graphql
+        elsif @mutation
+          field_inst = @mutation.graphql_field
+          return field_inst.to_graphql
+        end
+
         method_name = @method || @hash_key || Member::BuildType.underscore(@name)
 
         field_defn = if @field
@@ -138,7 +155,11 @@ module GraphQL
           return_type_name = Member::BuildType.to_type_name(@return_type_expr)
           connection = @connection.nil? ? return_type_name.end_with?("Connection") : @connection
           field_defn.type = -> {
-            Member::BuildType.parse_type(@return_type_expr, null: @return_type_null)
+            begin
+              Member::BuildType.parse_type(@return_type_expr, null: @return_type_null)
+            rescue
+              raise ArgumentError, "Failed to build return type for #{@owner.graphql_name}.#{name} from #{@return_type_expr.inspect}: #{$!.message}", $!.backtrace
+            end
           }
         elsif @connection.nil? && (@field || @function)
           return_type_name = Member::BuildType.to_type_name(field_defn.type)
@@ -155,6 +176,10 @@ module GraphQL
           field_defn.deprecation_reason = @deprecation_reason
         end
 
+        if @mutation_class
+          field_defn.mutation = @mutation_class
+        end
+
         field_defn.resolve = if @resolve || @function || @field
           prev_resolve = @resolve || field_defn.resolve_proc
           UnwrappedResolve.new(inner_resolve: prev_resolve)
@@ -182,25 +207,13 @@ module GraphQL
           argument :last, "Int", "Returns the last _n_ elements from the list.", required: false
         end
 
-        @arguments.each do |name, defn|
+        arguments.each do |name, defn|
           arg_graphql = defn.to_graphql
           field_defn.arguments[arg_graphql.name] = arg_graphql
         end
 
         field_defn
       end
-
-      private
-
-      class << self
-        def argument_class(new_arg_class = nil)
-          if new_arg_class
-            @argument_class = new_arg_class
-          else
-            @argument_class || GraphQL::Schema::Argument
-          end
-        end
-      end
     end
   end
 end

data/lib/graphql/schema/field/dynamic_resolve.rb

@@ -14,18 +14,18 @@ module GraphQL
         def call(obj, args, ctx)
           if obj.respond_to?(@method_name)
             public_send_field(obj, @method_name, args, ctx)
-          elsif obj.object.respond_to?(@method_name)
-            public_send_field(obj.object, @method_name, args, ctx)
           elsif obj.object.is_a?(Hash)
             inner_object = obj.object
             inner_object[@method_name] || inner_object[@method_sym]
+          elsif obj.object.respond_to?(@method_name)
+            public_send_field(obj.object, @method_name, args, ctx)
           else
             raise <<-ERR
 Failed to implement #{ctx.irep_node.owner_type.name}.#{ctx.field.name}, tried:
 
 - `#{obj.class}##{@method_name}`, which did not exist
 - `#{obj.object.class}##{@method_name}`, which did not exist
-- Looking up hash key `#{@method_name.inspect}` on `#{obj}`, but it wasn't a Hash
+- Looking up hash key `#{@method_name.inspect}` on `#{obj.object}`, but it wasn't a Hash
 
 To implement this field, define one of the methods above (and check for typos)
 ERR
@@ -39,11 +39,7 @@ ERR
         def public_send_field(obj, method_name, graphql_args, field_ctx)
           if graphql_args.any? || @extras.any?
             # Splat the GraphQL::Arguments to Ruby keyword arguments
-            ruby_kwargs = {}
-
-            graphql_args.keys.each do |key|
-              ruby_kwargs[Schema::Member::BuildType.underscore(key).to_sym] = graphql_args[key]
-            end
+            ruby_kwargs = graphql_args.to_kwargs
 
             if @connection
               # Remove pagination args before passing it to a user method