graphql 1.8.0.pre10 → 1.8.0.pre11

data/lib/graphql/schema/finder.rb

@@ -5,16 +5,16 @@ module GraphQL
     # Find schema members using string paths
     #
     # @example Finding object types
-    # MySchema.find("SomeObjectType")
+    #   MySchema.find("SomeObjectType")
     #
     # @example Finding fields
-    # MySchema.find("SomeObjectType.myField")
+    #   MySchema.find("SomeObjectType.myField")
     #
     # @example Finding arguments
-    # MySchema.find("SomeObjectType.myField.anArgument")
+    #   MySchema.find("SomeObjectType.myField.anArgument")
     #
     # @example Finding directives
-    # MySchema.find("@include")
+    #   MySchema.find("@include")
     #
     class Finder
       class MemberNotFoundError < ArgumentError; end

data/lib/graphql/schema/input_object.rb

@@ -3,14 +3,21 @@ module GraphQL
   class Schema
     class InputObject < GraphQL::Schema::Member
       extend GraphQL::Schema::Member::AcceptsDefinition
-      extend GraphQL::Delegate
+      extend Forwardable
       extend GraphQL::Schema::Member::HasArguments
 
       def initialize(values, 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
-        @context = context
+        # Apply prepares, not great to have it duplicated here.
+        self.class.arguments.each do |name, arg_defn|
+          ruby_kwargs_key = arg_defn.keyword
+          if @ruby_style_hash.key?(ruby_kwargs_key) && arg_defn.prepare
+            @ruby_style_hash[ruby_kwargs_key] = arg_defn.prepare_value(self, @ruby_style_hash[ruby_kwargs_key])
+          end
+        end
       end
 
       # @return [GraphQL::Query::Context] The context for this query
@@ -70,6 +77,10 @@ module GraphQL
           type_defn.arguments_class = self
           type_defn
         end
+
+        def kind
+          GraphQL::TypeKinds::INPUT_OBJECT
+        end
       end
     end
   end

data/lib/graphql/schema/interface.rb

@@ -1,25 +1,44 @@
 # frozen_string_literal: true
 module GraphQL
   class Schema
-    class Interface < GraphQL::Schema::Member
-      extend GraphQL::Schema::Member::HasFields
-      extend GraphQL::Schema::Member::AcceptsDefinition
+    module Interface
+      include GraphQL::Schema::Member::GraphQLTypeNames
+      module DefinitionMethods
+        include GraphQL::Schema::Member::CachedGraphQLDefinition
+        include GraphQL::Relay::TypeExtensions
+        include GraphQL::Schema::Member::BaseDSLMethods
+        include GraphQL::Schema::Member::TypeSystemHelpers
+        include GraphQL::Schema::Member::HasFields
 
-      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)
+        # Methods defined in this block will be:
+        # - Added as class methods to this interface
+        # - Added as class methods to all child interfaces
+        def definition_methods(&block)
+          self::DefinitionMethods.module_eval(&block)
         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 implemented(object_class)
-          object_class.include(self::Implementation)
+        # Here's the tricky part. Make sure behavior keeps making its way down the inheritance chain.
+        def included(child_class)
+          if !child_class.is_a?(Class)
+            # In this case, it's been included into another interface.
+            # This is how interface inheritance is implemented
+            child_class.const_set(:DefinitionMethods, Module.new)
+            child_class.extend(child_class::DefinitionMethods)
+            # We need this before we can call `own_interfaces`
+            child_class.extend(Schema::Interface::DefinitionMethods)
+            child_class.own_interfaces << self
+            child_class.own_interfaces.each do |interface_defn|
+              child_class.extend(interface_defn::DefinitionMethods)
+            end
+          elsif child_class < GraphQL::Schema::Object
+            # This is being included into an object type, make sure it's using `implements(...)`
+            backtrace_line = caller(0, 10).find { |line| line.include?("schema/object.rb") && line.include?("in `implements'")}
+            if !backtrace_line
+              raise "Attach interfaces using `implements(#{self})`, not `include(#{self})`"
+            end
+          end
+
+          super
         end
 
         def orphan_types(*types)
@@ -47,7 +66,22 @@ module GraphQL
           end
           type_defn
         end
+
+        def kind
+          GraphQL::TypeKinds::INTERFACE
+        end
+
+        protected
+
+        def own_interfaces
+          @own_interfaces ||= []
+        end
       end
+
+      # Extend this _after_ `DefinitionMethods` is defined, so it will be used
+      extend GraphQL::Schema::Member::AcceptsDefinition
+
+      extend DefinitionMethods
     end
   end
 end

data/lib/graphql/schema/list.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    # Represents a list type in the schema.
+    # Wraps a {Schema::Member} as a list type.
+    # @see {Schema::Member::TypeSystemHelpers#to_list_type}
+    class List
+      include GraphQL::Schema::Member::CachedGraphQLDefinition
+      include GraphQL::Schema::Member::TypeSystemHelpers
+
+      # @return [Class, Module] The inner type of this list, the type of which one or more objects may be present.
+      attr_reader :of_type
+
+      def initialize(of_type)
+        @of_type = of_type
+      end
+
+      def to_graphql
+        @of_type.graphql_definition.to_list_type
+      end
+
+      def kind
+        GraphQL::TypeKinds::LIST
+      end
+    end
+  end
+end

data/lib/graphql/schema/member.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 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/type_system_helpers'
 require "graphql/relay/type_extensions"
 
 module GraphQL
@@ -9,117 +13,15 @@ module GraphQL
   # @api private
   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`.
-      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
-
-        def initialize_copy(original)
-          super
-          @graphql_definition = nil
-        end
-      end
-
-      # These constants are interpreted as GraphQL types
-      #
-      # @example
-      #   field :is_draft, Boolean, null: false
-      #   field :id, ID, null: false
-      #   field :score, Int, null: false
-      module GraphQLTypeNames
-        Boolean = "Boolean"
-        ID = "ID"
-        Int = "Int"
-      end
-
       include GraphQLTypeNames
-      class << self
-        include CachedGraphQLDefinition
-        include GraphQL::Relay::TypeExtensions
-        # Call this with a new name to override the default name for this schema member; OR
-        # call it without an argument to get the name of this schema member
-        #
-        # The default name is the Ruby constant name,
-        # without any namespaces and with any `-Type` suffix removed
-        # @param new_name [String]
-        # @return [String]
-        def graphql_name(new_name = nil)
-          if new_name
-            @graphql_name = new_name
-          else
-            overridden_graphql_name || self.name.split("::").last.sub(/Type\Z/, "")
-          end
-        end
-
-        # Just a convenience method to point out that people should use graphql_name instead
-        def name(new_name = nil)
-          return super() if new_name.nil?
-
-          fail(
-            "The new name override method is `graphql_name`, not `name`. Usage: "\
-            "graphql_name \"#{new_name}\""
-          )
-        end
-
-        # Call this method to provide a new description; OR
-        # call it without an argument to get the description
-        # @param new_description [String]
-        # @return [String]
-        def description(new_description = nil)
-          if new_description
-            @description = new_description
-          else
-            @description || (superclass <= GraphQL::Schema::Member ? superclass.description : nil)
-          end
-        end
-
-        # @return [Boolean] If true, this object is part of the introspection system
-        def introspection(new_introspection = nil)
-          if !new_introspection.nil?
-            @introspection = new_introspection
-          else
-            @introspection || (superclass <= Schema::Member ? superclass.introspection : false)
-          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
-
-        def to_list_type
-          ListTypeProxy.new(self)
-        end
-
-        def to_non_null_type
-          NonNullTypeProxy.new(self)
-        end
-
-        protected
-
-        def overridden_graphql_name
-          @graphql_name || (superclass <= GraphQL::Schema::Member ? superclass.overridden_graphql_name : nil)
-        end
-      end
+      extend CachedGraphQLDefinition
+      extend GraphQL::Relay::TypeExtensions
+      extend BaseDSLMethods
+      extend TypeSystemHelpers
     end
   end
 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'

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

@@ -37,47 +37,81 @@ module GraphQL
       #   Account.graphql_definition.metadata[:permission_level] # => 1
       module AcceptsDefinition
         def self.included(child)
-          child.extend(ClassMethods)
+          child.extend(AcceptsDefinitionDefinitionMethods)
           child.prepend(ToGraphQLExtension)
           child.prepend(InitializeExtension)
         end
 
         def self.extended(child)
-          child.extend(ClassMethods)
-          # I tried to use `super`, but super isn't quite right
-          # since the method is defined in the same class itself,
-          # not the superclass
-          child.class_eval do
-            class << self
-              prepend(ToGraphQLExtension)
+          if defined?(child::DefinitionMethods)
+            child::DefinitionMethods.include(AcceptsDefinitionDefinitionMethods)
+            child::DefinitionMethods.prepend(ToGraphQLExtension)
+          else
+            child.extend(AcceptsDefinitionDefinitionMethods)
+            # I tried to use `super`, but super isn't quite right
+            # since the method is defined in the same class itself,
+            # not the superclass
+            child.class_eval do
+              class << self
+                prepend(ToGraphQLExtension)
+              end
             end
           end
         end
 
-        module ClassMethods
+        module AcceptsDefinitionDefinitionMethods
           def accepts_definition(name)
-            @accepts_definition_methods ||= []
-            @accepts_definition_methods << name
+            own_accepts_definition_methods << name
+
             ivar_name = "@#{name}_args"
-            define_singleton_method(name) do |*args|
-              if args.any?
-                instance_variable_set(ivar_name, args)
+            if self.is_a?(Class)
+              define_singleton_method(name) do |*args|
+                if args.any?
+                  instance_variable_set(ivar_name, args)
+                end
+                instance_variable_get(ivar_name)
               end
-              instance_variable_get(ivar_name)
-            end
 
-            define_method(name) do |*args|
-              if args.any?
-                instance_variable_set(ivar_name, args)
+              define_method(name) do |*args|
+                if args.any?
+                  instance_variable_set(ivar_name, args)
+                end
+                instance_variable_get(ivar_name)
+              end
+            else
+              # Special handling for interfaces, define it here
+              # so it's appropriately passed down
+              self::DefinitionMethods.module_eval do
+                define_method(name) do |*args|
+                  if args.any?
+                    instance_variable_set(ivar_name, args)
+                  end
+                  instance_variable_get(ivar_name)
+                end
               end
-              instance_variable_get(ivar_name)
             end
           end
 
           def accepts_definition_methods
-            @accepts_definition_methods ||= []
-            sc = self.is_a?(Class) ? superclass : self.class.superclass
-            @accepts_definition_methods + (sc.respond_to?(:accepts_definition_methods) ? sc.accepts_definition_methods : [])
+            inherited_methods = if self.is_a?(Class)
+              superclass.respond_to?(:accepts_definition_methods) ? superclass.accepts_definition_methods : []
+            elsif self.is_a?(Module)
+              m = []
+              ancestors.each do |a|
+                if a.respond_to?(:own_accepts_definition_methods)
+                  m.concat(a.own_accepts_definition_methods)
+                end
+              end
+              m
+            else
+              self.class.accepts_definition_methods
+            end
+
+            own_accepts_definition_methods + inherited_methods
+          end
+
+          def own_accepts_definition_methods
+            @own_accepts_definition_methods ||= []
           end
         end
 
@@ -85,7 +119,7 @@ module GraphQL
           def to_graphql
             defn = super
             accepts_definition_methods.each do |method_name|
-              value = instance_variable_get("@#{method_name}_args")
+              value = public_send(method_name)
               if !value.nil?
                 defn = defn.redefine { public_send(method_name, *value) }
               end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      # DSL methods shared by lots of things in the GraphQL Schema.
+      # @api private
+      # @see Classes that extend this, eg {GraphQL::Schema::Object}
+      module BaseDSLMethods
+        # Call this with a new name to override the default name for this schema member; OR
+        # call it without an argument to get the name of this schema member
+        #
+        # The default name is the Ruby constant name,
+        # without any namespaces and with any `-Type` suffix removed
+        # @param new_name [String]
+        # @return [String]
+        def graphql_name(new_name = nil)
+          case
+          when new_name
+            @graphql_name = new_name
+          when overridden = overridden_graphql_name
+            overridden
+          else # Fallback to Ruby constant name
+            raise NotImplementedError, 'Anonymous class should declare an `graphql_name`' if name.nil?
+            
+            name.split("::").last.sub(/Type\Z/, "")
+          end
+        end
+
+        # Just a convenience method to point out that people should use graphql_name instead
+        def name(new_name = nil)
+          return super() if new_name.nil?
+
+          fail(
+            "The new name override method is `graphql_name`, not `name`. Usage: "\
+            "graphql_name \"#{new_name}\""
+          )
+        end
+
+        # Call this method to provide a new description; OR
+        # call it without an argument to get the description
+        # @param new_description [String]
+        # @return [String]
+        def description(new_description = nil)
+          if new_description
+            @description = new_description
+          else
+            @description || find_inherited_method(:description, nil)
+          end
+        end
+
+        # @return [Boolean] If true, this object is part of the introspection system
+        def introspection(new_introspection = nil)
+          if !new_introspection.nil?
+            @introspection = new_introspection
+          else
+            @introspection || find_inherited_method(:introspection, false)
+          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
+
+        # @return [GraphQL::BaseType] Convert this type to a legacy-style object.
+        def to_graphql
+          raise NotImplementedError
+        end
+
+        def overridden_graphql_name
+          @graphql_name || find_inherited_method(:overridden_graphql_name, nil)
+        end
+
+        private
+
+        def find_inherited_method(method_name, default_value)
+          if self.is_a?(Class)
+            superclass.respond_to?(method_name) ? superclass.public_send(method_name) : default_value
+          else
+            ancestors[1..-1].each do |ancestor|
+              if ancestor.respond_to?(method_name)
+                return ancestor.public_send(method_name)
+              end
+            end
+            default_value
+          end
+        end
+      end
+    end
+  end
+end