graphql 1.8.0.pre9 → 1.8.0.pre10

data/lib/graphql/schema/input_object.rb

@@ -4,9 +4,12 @@ module GraphQL
     class InputObject < GraphQL::Schema::Member
       extend GraphQL::Schema::Member::AcceptsDefinition
       extend GraphQL::Delegate
+      extend GraphQL::Schema::Member::HasArguments
 
       def initialize(values, context:, defaults_used:)
         @arguments = self.class.arguments_class.new(values, context: context, defaults_used: defaults_used)
+        # Symbolized, underscored hash:
+        @ruby_style_hash = @arguments.to_kwargs
         @context = context
       end
 
@@ -16,40 +19,48 @@ module GraphQL
       # @return [GraphQL::Query::Arguments] The underlying arguments instance
       attr_reader :arguments
 
-      # A lot of methods work just like GraphQL::Arguments
-      def_delegators :@arguments, :[], :key?, :to_h
-      def_delegators :to_h, :keys, :values, :each, :any?
+      # Ruby-like hash behaviors, read-only
+      def_delegators :@ruby_style_hash, :to_h, :keys, :values, :each, :any?
+
+      # Lookup a key on this object, it accepts new-style underscored symbols
+      # Or old-style camelized identifiers.
+      # @param key [Symbol, String]
+      def [](key)
+        if @ruby_style_hash.key?(key)
+          @ruby_style_hash[key]
+        else
+          @arguments[key]
+        end
+      end
+
+      def key?(key)
+        @ruby_style_hash.key?(key) || @arguments.key?(key)
+      end
+
+      # A copy of the Ruby-style hash
+      def to_kwargs
+        @ruby_style_hash.dup
+      end
 
       class << self
         # @return [Class<GraphQL::Arguments>]
         attr_accessor :arguments_class
 
-        def argument(*args, **kwargs)
-          kwargs[:owner] = self
-          argument = GraphQL::Schema::Argument.new(*args, **kwargs)
-          arg_name = argument.graphql_definition.name
-          own_arguments[arg_name] = argument
+        def argument(*args)
+          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)
           end
         end
 
-        # @return [Hash<String => GraphQL::Schema::Argument] Input fields on this input object, keyed by name.
-        def arguments
-          inherited_arguments = (superclass <= GraphQL::Schema::InputObject ? superclass.arguments : {})
-          # Local definitions override inherited ones
-          inherited_arguments.merge(own_arguments)
-        end
-
-        def own_arguments
-          @own_arguments ||= {}
-        end
-
         def to_graphql
           type_defn = GraphQL::InputObjectType.new
           type_defn.name = graphql_name
           type_defn.description = description
+          type_defn.metadata[:type_class] = self
+          type_defn.mutation = mutation
           arguments.each do |name, arg|
             type_defn.arguments[arg.graphql_definition.name] = arg.graphql_definition
           end

data/lib/graphql/schema/interface.rb

@@ -4,16 +4,22 @@ module GraphQL
     class Interface < GraphQL::Schema::Member
       extend GraphQL::Schema::Member::HasFields
       extend GraphQL::Schema::Member::AcceptsDefinition
-      field_class GraphQL::Schema::Field
 
       class << self
+        # Always set up a `self::Implementation` module,
+        # which may or may not be added to.
+        def inherited(child_cls)
+          # This module will be mixed in to each object class,
+          # so it can contain methods to implement fields.
+          # It's always added to interfaces, but sometimes it's left empty.
+          child_cls.const_set(:Implementation, Module.new)
+        end
+
         # When this interface is added to a `GraphQL::Schema::Object`,
         # it calls this method. We add methods to the object by convention,
         # a nested module named `Implementation`
-        def apply_implemented(object_class)
-          if defined?(self::Implementation)
-            object_class.include(self::Implementation)
-          end
+        def implemented(object_class)
+          object_class.include(self::Implementation)
         end
 
         def orphan_types(*types)
@@ -35,6 +41,7 @@ module GraphQL
             field_defn = field_inst.graphql_definition
             type_defn.fields[field_defn.name] = field_defn
           end
+          type_defn.metadata[:type_class] = self
           if respond_to?(:resolve_type)
             type_defn.resolve_type = method(:resolve_type)
           end

data/lib/graphql/schema/member.rb

@@ -87,6 +87,15 @@ module GraphQL
           end
         end
 
+        # The mutation this type was derived from, if it was derived from a mutation
+        # @return [Class]
+        def mutation(mutation_class = nil)
+          if mutation_class
+            @mutation = mutation_class
+          end
+          @mutation
+        end
+
         def to_graphql
           raise NotImplementedError
         end
@@ -111,6 +120,7 @@ end
 
 require 'graphql/schema/member/list_type_proxy'
 require 'graphql/schema/member/non_null_type_proxy'
+require 'graphql/schema/member/has_arguments'
 require 'graphql/schema/member/has_fields'
 require 'graphql/schema/member/instrumentation'
 require 'graphql/schema/member/build_type'

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

@@ -64,12 +64,14 @@ module GraphQL
               raise ArgumentError, LIST_TYPE_ERROR
             end
           when Class
-            if Class < GraphQL::Schema::Member
+            if type_expr < GraphQL::Schema::Member
               type_expr.graphql_definition
             else
               # Eg `String` => GraphQL::STRING_TYPE
               parse_type(type_expr.name, null: true)
             end
+          else
+            raise "Unexpected type_expr input: #{type_expr} (#{type_expr.class})"
           end
 
           # Apply list_type first, that way the

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Member
+      module HasArguments
+        def self.included(cls)
+          cls.extend(ArgumentClassAccessor)
+        end
+
+        def self.extended(cls)
+          cls.extend(ArgumentClassAccessor)
+        end
+
+        # @see {GraphQL::Schema::Argument#initialize} for parameters
+        # @return [GraphQL::Schema::Argument] An instance of {arguments_class}, created from `*args`
+        def argument(*args, **kwargs, &block)
+          kwargs[:owner] = self
+          arg_defn = self.argument_class.new(*args, **kwargs, &block)
+          own_arguments[arg_defn.name] = arg_defn
+        end
+
+        # @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 <= GraphQL::Schema::Member::HasArguments) ? superclass.arguments : {})
+          # Local definitions override inherited ones
+          inherited_arguments.merge(own_arguments)
+        end
+
+        # @param new_arg_class [Class] A class to use for building argument definitions
+        def argument_class(new_arg_class = nil)
+          self.class.argument_class(new_arg_class)
+        end
+
+        module ArgumentClassAccessor
+          def argument_class(new_arg_class = nil)
+            if new_arg_class
+              @argument_class = new_arg_class
+            else
+              @argument_class || (superclass.respond_to?(:argument_class) ? superclass.argument_class : GraphQL::Schema::Argument)
+            end
+          end
+        end
+
+        def own_arguments
+          @own_arguments ||= {}
+        end
+      end
+    end
+  end
+end

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

@@ -34,7 +34,7 @@ module GraphQL
           if new_field_class
             @field_class = new_field_class
           else
-            @field_class || superclass.field_class
+            @field_class || (superclass.respond_to?(:field_class) ? superclass.field_class : GraphQL::Schema::Field)
           end
         end
 

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

@@ -8,9 +8,9 @@ module GraphQL
         module_function
         def instrument(type, field)
           return_type = field.type.unwrap
-          if return_type.metadata[:object_class] ||
+          if (return_type.is_a?(GraphQL::ObjectType) && return_type.metadata[:type_class]) ||
               return_type.is_a?(GraphQL::InterfaceType) ||
-              (return_type.is_a?(GraphQL::UnionType) && return_type.possible_types.any? { |t| t.metadata[:object_class] })
+              (return_type.is_a?(GraphQL::UnionType) && return_type.possible_types.any? { |t| t.metadata[:type_class] })
             field = apply_proxy(field)
           end
 
@@ -25,7 +25,7 @@ module GraphQL
           else
             root_type = query.irep_selection.return_type
             # If it has a wrapper, apply it
-            wrapper_class = root_type.metadata[:object_class]
+            wrapper_class = root_type.metadata[:type_class]
             if wrapper_class
               new_root_value = wrapper_class.new(query.root_value, query.context)
               query.root_value = new_root_value
@@ -99,7 +99,7 @@ module GraphQL
                 raise "unexpected proxying type #{type} for #{obj} at #{ctx.owner_type}.#{ctx.field.name}"
               end
 
-              if concrete_type && (object_class = concrete_type.metadata[:object_class])
+              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.new(obj, query_ctx)

data/lib/graphql/schema/mutation.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    # This base class accepts configuration for a mutation root field,
+    # then it can be hooked up to your mutation root object type.
+    #
+    # If you want to customize how this class generates types, in your base class,
+    # override the various `generate_*` methods.
+    #
+    # @see {GraphQL::Schema::RelayClassicMutation} for an extension of this class with some conventions built-in.
+    #
+    # @example Creating a comment
+    #  # Define the mutation:
+    #  class Mutations::CreateComment < GraphQL::Schema::Mutation
+    #    argument :body, String, required: true
+    #    argument :post_id, ID, required: true
+    #
+    #    field :comment, Types::Comment, null: true
+    #    field :error_messages, [String], null: false
+    #
+    #    def resolve(body:, post_id:)
+    #      post = Post.find(post_id)
+    #      comment = post.comments.build(body: body, author: context[:current_user])
+    #      if comment.save
+    #        # Successful creation, return the created object with no errors
+    #        {
+    #          comment: comment,
+    #          errors: [],
+    #        }
+    #      else
+    #        # Failed save, return the errors to the client
+    #        {
+    #          comment: nil,
+    #          errors: comment.errors.full_messages
+    #        }
+    #      end
+    #    end
+    #  end
+    #
+    #  # Hook it up to your mutation:
+    #  class Types::Mutation < GraphQL::Schema::Object
+    #    field :create_comment, mutation: Mutations::CreateComment
+    #  end
+    #
+    #  # Call it from GraphQL:
+    #  result = MySchema.execute <<-GRAPHQL
+    #  mutation {
+    #    createComment(postId: "1", body: "Nice Post!") {
+    #      errors
+    #      comment {
+    #        body
+    #        author {
+    #          login
+    #        }
+    #      }
+    #    }
+    #  }
+    #  GRAPHQL
+    #
+    class Mutation < GraphQL::Schema::Member
+      extend GraphQL::Schema::Member::HasFields
+      extend GraphQL::Schema::Member::HasArguments
+
+      # @param object [Object] the initialize object, pass to {Query.initialize} as `root_value`
+      # @param context [GraphQL::Query::Context]
+      def initialize(object:, context:, arguments:)
+        @object = object
+        @context = context
+      end
+
+      # @return [Object] the root value of the operation
+      attr_reader :object
+
+      # @return [GraphQL::Query::Context]
+      attr_reader :context
+
+      # Do the work. Everything happens here.
+      # @return [Hash] A key for each field in the return type
+      # @return [Object] An object corresponding to the return type
+      def resolve(**args)
+        raise NotImplementedError, "#{self.class.name}#resolve should execute side effects and return a Symbol-keyed hash"
+      end
+
+      class << self
+        # Override the method from HasFields to support `field: Mutation.field`, for backwards compat.
+        #
+        # If called without any arguments, returns a `GraphQL::Field`.
+        # @see {GraphQL::Schema::Member::HasFields.field} for default behavior
+        def field(*args, &block)
+          if args.none? && !block_given?
+            graphql_field.graphql_definition
+          else
+            super(*args, &block)
+          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
+
+        # @return [GraphQL::Schema::Field] The generated field instance for this mutation
+        # @see {GraphQL::Schema::Field}'s `mutation:` option, don't call this directly
+        def graphql_field
+          @graphql_field ||= generate_field
+        end
+
+        # @param new_name [String, nil] if present, override the class name to set this value
+        # @return [String] The name of this mutation in the GraphQL schema (used for naming derived types and fields)
+        def graphql_name(new_name = nil)
+          if new_name
+            @graphql_name = new_name
+          end
+          @graphql_name ||= self.name.split("::").last
+        end
+
+        # An object class to use for deriving payload 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
+
+        # Additional info injected into {#resolve}
+        # @see {GraphQL::Schema::Field#extras}
+        def extras(new_extras = nil)
+          if new_extras
+            @extras = new_extras
+          end
+          @extras || []
+        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
+          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
+        end
+
+        # This name will be used for the {.graphql_field}.
+        def field_name
+          graphql_name.sub(/^[A-Z]/, &:downcase)
+        end
+
+        # Build an instance of {.field_class} which will be used to execute this mutation.
+        # To customize field generation, override this method.
+        def generate_field
+          # TODO support deprecation_reason
+          self.field_class.new(
+            field_name,
+            payload_type,
+            description,
+            resolve: self.method(:resolve_field),\
+            mutation_class: self,
+            arguments: arguments,
+            null: true,
+          )
+        end
+
+        # This is basically the `.call` behavior for the generated field,
+        # instantiating the Mutation class and calling its {#resolve} method
+        # with Ruby keyword arguments.
+        def resolve_field(obj, args, ctx)
+          mutation = self.new(object: obj, arguments: args, context: ctx.query.context)
+          ruby_kwargs = args.to_kwargs
+          extras.each { |e| ruby_kwargs[e] = ctx.public_send(e) }
+          mutation.resolve(**ruby_kwargs)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/object.rb

@@ -4,6 +4,7 @@ module GraphQL
   class Schema
     class Object < GraphQL::Schema::Member
       extend GraphQL::Schema::Member::AcceptsDefinition
+      extend GraphQL::Schema::Member::HasFields
 
       # @return [Object] the application object this type is wrapping
       attr_reader :object
@@ -16,9 +17,6 @@ module GraphQL
         @context = context
       end
 
-      extend GraphQL::Schema::Member::HasFields
-      field_class GraphQL::Schema::Field
-
       class << self
         def implements(*new_interfaces)
           new_interfaces.each do |int|
@@ -28,7 +26,7 @@ module GraphQL
                 own_fields[name] = field
               end
               # And call the implemented hook
-              int.apply_implemented(self)
+              int.implemented(self)
             else
               int.all_fields.each do |f|
                 field(f.name, field: f)
@@ -53,13 +51,14 @@ module GraphQL
           obj_type.description = description
           obj_type.interfaces = interfaces
           obj_type.introspection = introspection
+          obj_type.mutation = mutation
 
           fields.each do |field_name, field_inst|
             field_defn = field_inst.to_graphql
             obj_type.fields[field_defn.name] = field_defn
           end
 
-          obj_type.metadata[:object_class] = self
+          obj_type.metadata[:type_class] = self
 
           obj_type
         end