graphql 1.8.0.pre10 → 1.8.0.pre11

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

@@ -37,11 +37,12 @@ module GraphQL
               case maybe_type
               when GraphQL::BaseType
                 maybe_type
-              when Class
-                if maybe_type < GraphQL::Schema::Member
-                  maybe_type.graphql_definition
+              when Module
+                # This is a way to check that it's the right kind of module:
+                if maybe_type.respond_to?(:graphql_definition)
+                  maybe_type
                 else
-                  raise "Unexpected class found for GraphQL type: #{type_expr} (must be GraphQL::Object)"
+                  raise ArgumentError, "Unexpected class/module found for GraphQL type: #{type_expr} (must be type definition class/module)"
                 end
               end
             end
@@ -63,15 +64,20 @@ module GraphQL
             else
               raise ArgumentError, LIST_TYPE_ERROR
             end
-          when Class
-            if type_expr < GraphQL::Schema::Member
-              type_expr.graphql_definition
+          when Module
+            # This is a way to check that it's the right kind of module:
+            if type_expr.respond_to?(:graphql_definition)
+              type_expr
             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})"
+          when false
+            raise ArgumentError, "Received `false` instead of a type, maybe a `!` should be replaced with `null: true` (for fields) or `required: true` (for arguments)"
+          end
+
+          if return_type.nil?
+            raise "Unexpected type input: #{type_expr} (#{type_expr.class})"
           end
 
           # Apply list_type first, that way the

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      # Adds a layer of caching over user-supplied `.to_graphql` methods.
+      # Users override `.to_graphql`, but all runtime code should use `.graphql_definition`.
+      # @api private
+      # @see concrete classes that extend this, eg {Schema::Object}
+      module CachedGraphQLDefinition
+        # A cached result of {.to_graphql}.
+        # It's cached here so that user-overridden {.to_graphql} implementations
+        # are also cached
+        def graphql_definition
+          @graphql_definition ||= to_graphql
+        end
+
+        # Wipe out the cached graphql_definition so that `.to_graphql` will be called again.
+        def initialize_copy(original)
+          super
+          @graphql_definition = nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      # These constants are interpreted as GraphQL types when defining fields or arguments
+      #
+      # @example
+      #   field :is_draft, Boolean, null: false
+      #   field :id, ID, null: false
+      #   field :score, Int, null: false
+      #
+      # @api private
+      module GraphQLTypeNames
+        Boolean = "Boolean"
+        ID = "ID"
+        Int = "Int"
+      end
+    end
+  end
+end

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

@@ -21,7 +21,7 @@ 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 <= GraphQL::Schema::Member::HasArguments) ? superclass.arguments : {})
+          inherited_arguments = ((self.is_a?(Class) && superclass.respond_to?(:arguments)) ? superclass.arguments : {})
           # Local definitions override inherited ones
           inherited_arguments.merge(own_arguments)
         end

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

@@ -4,28 +4,78 @@ 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]
         def field(*args, **kwargs, &block)
-          kwargs[:owner] = self
-          field_defn = field_class.new(*args, **kwargs, &block)
+          field_defn = build_field(*args, **kwargs, &block)
           add_field(field_defn)
           nil
         end
 
         # @return [Hash<String => GraphQL::Schema::Field>] Fields on this object, keyed by name, including inherited fields
         def fields
-          inherited_fields = (superclass.is_a?(HasFields) ? superclass.fields : {})
           # Local overrides take precedence over inherited fields
-          inherited_fields.merge(own_fields)
+          all_fields = {}
+          ancestors.reverse_each do |ancestor|
+            if ancestor.respond_to?(:own_fields)
+              all_fields.merge!(ancestor.own_fields)
+            end
+          end
+          all_fields
         end
 
-        # Register this field with the class, overriding a previous one if needed
+        # 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
 
@@ -33,8 +83,13 @@ module GraphQL
         def field_class(new_field_class = nil)
           if new_field_class
             @field_class = new_field_class
+          elsif @field_class
+            @field_class
+          elsif self.is_a?(Class)
+            superclass.respond_to?(:field_class) ? superclass.field_class : GraphQL::Schema::Field
           else
-            @field_class || (superclass.respond_to?(:field_class) ? superclass.field_class : GraphQL::Schema::Field)
+            ancestor = ancestors[1..-1].find { |a| a.respond_to?(:field_class) && a.field_class }
+            ancestor ? ancestor.field_class : GraphQL::Schema::Field
           end
         end
 
@@ -42,12 +97,40 @@ module GraphQL
           field field_name, "ID", null: false, resolve: GraphQL::Relay::GlobalIdResolve.new(type: self)
         end
 
-        private
-
         # @return [Array<GraphQL::Schema::Field>] Fields defined on this class _specifically_, not parent classes
         def own_fields
           @own_fields ||= {}
         end
+
+        private
+
+        # Initialize a field with this class's field class, but don't attach it.
+        def build_field(*args, **kwargs, &block)
+          kwargs[:owner] = self
+          field_class.new(*args, **kwargs, &block)
+        end
+
+        # 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/type_system_helpers.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      module TypeSystemHelpers
+        # @return [Schema::NonNull] Make a non-null-type representation of this type
+        def to_non_null_type
+          GraphQL::Schema::NonNull.new(self)
+        end
+
+        # @return [Schema::List] Make a list-type representation of this type
+        def to_list_type
+          GraphQL::Schema::List.new(self)
+        end
+
+        # @return [Boolean] true if this is a non-nullable type. A nullable list of non-nullables is considered nullable.
+        def non_null?
+          false
+        end
+
+        # @return [Boolean] true if this is a list type. A non-nullable list is considered a list.
+        def list?
+          false
+        end
+
+        # @return [GraphQL::TypeKinds::TypeKind]
+        def kind
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/middleware_chain.rb

@@ -5,7 +5,7 @@ module GraphQL
     #
     # Steps should call `next_step.call` to continue the chain, or _not_ call it to stop the chain.
     class MiddlewareChain
-      extend GraphQL::Delegate
+      extend Forwardable
 
       # @return [Array<#call(*args)>] Steps in this chain, will be called with arguments and `next_middleware`
       attr_reader :steps, :final_step
@@ -38,6 +38,10 @@ module GraphQL
         invoke_core(0, arguments)
       end
 
+      def concat(callables)
+        callables.each { |c| add_middleware(c) }
+      end
+
       private
 
       def invoke_core(index, arguments)

data/lib/graphql/schema/mutation.rb

@@ -82,7 +82,18 @@ module GraphQL
         raise NotImplementedError, "#{self.class.name}#resolve should execute side effects and return a Symbol-keyed hash"
       end
 
+      # This is a hook for classes to intercept resolution.
+      # @see RelayClassicMutation for usage
+      def resolve_mutation(args)
+        resolve(args)
+      end
+
       class << self
+        def inherited(base)
+          base.null(null)
+          super
+        end
+
         # Override the method from HasFields to support `field: Mutation.field`, for backwards compat.
         #
         # If called without any arguments, returns a `GraphQL::Field`.
@@ -141,6 +152,16 @@ module GraphQL
           @extras || []
         end
 
+        # Specifies whether or not the mutation is nullable. Defaults to `true`
+        # @param allow_null [Boolean] Whether or not the response can be null
+        def null(allow_null = nil)
+          unless allow_null.nil?
+            @null = allow_null
+          end
+
+          @null.nil? ? true : @null
+        end
+
         private
 
         # Build a subclass of {.object_class} based on `self`.
@@ -173,22 +194,13 @@ module GraphQL
             field_name,
             payload_type,
             description,
-            resolve: self.method(:resolve_field),\
+            extras: extras,
+            method: :resolve_mutation,
             mutation_class: self,
             arguments: arguments,
-            null: true,
+            null: null,
           )
         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

data/lib/graphql/schema/non_null.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    # Wraps a {Schema::Member} when it is required.
+    # @see {Schema::Member::TypeSystemHelpers#to_non_null_type}
+    class NonNull
+      include GraphQL::Schema::Member::CachedGraphQLDefinition
+      include GraphQL::Schema::Member::TypeSystemHelpers
+      attr_reader :of_type
+      def initialize(of_type)
+        @of_type = of_type
+      end
+
+      def to_graphql
+        @of_type.graphql_definition.to_non_null_type
+      end
+
+      # @return [true]
+      def non_null?
+        true
+      end
+
+      # @return [Boolean] True if this type wraps a list type
+      def list?
+        @of_type.list?
+      end
+
+      def kind
+        GraphQL::TypeKinds::NON_NULL
+      end
+    end
+  end
+end

data/lib/graphql/schema/object.rb

@@ -20,17 +20,11 @@ module GraphQL
       class << self
         def implements(*new_interfaces)
           new_interfaces.each do |int|
-            if int.is_a?(Class) && int < GraphQL::Schema::Interface
-              # Add the graphql field defns
-              int.fields.each do |name, field|
-                own_fields[name] = field
-              end
-              # And call the implemented hook
-              int.implemented(self)
-            else
-              int.all_fields.each do |f|
-                field(f.name, field: f)
-              end
+            if int.is_a?(Module)
+              # Include the methods here,
+              # `.fields` will use the inheritance chain
+              # to find inherited fields
+              include(int)
             end
           end
           own_interfaces.concat(new_interfaces)
@@ -44,6 +38,21 @@ module GraphQL
           @own_interfaces ||= []
         end
 
+        # Include legacy-style interfaces, too
+        def fields
+          all_fields = super
+          interfaces.each do |int|
+            if int.is_a?(GraphQL::InterfaceType)
+              int_f = {}
+              int.fields.each do |name, legacy_field|
+                int_f[name] = build_field(name, field: legacy_field)
+              end
+              all_fields = int_f.merge(all_fields)
+            end
+          end
+          all_fields
+        end
+
         # @return [GraphQL::ObjectType]
         def to_graphql
           obj_type = GraphQL::ObjectType.new
@@ -62,6 +71,10 @@ module GraphQL
 
           obj_type
         end
+
+        def kind
+          GraphQL::TypeKinds::OBJECT
+        end
       end
     end
   end