graphql 1.8.0 → 1.12.12

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

@@ -1,57 +1,17 @@
 # frozen_string_literal: true
+
 module GraphQL
   class Schema
     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]
+        # @return [GraphQL::Schema::Field]
         def field(*args, **kwargs, &block)
           field_defn = field_class.from_options(*args, owner: self, **kwargs, &block)
           add_field(field_defn)
-          nil
+          field_defn
         end
 
         # @return [Hash<String => GraphQL::Schema::Field>] Fields on this object, keyed by name, including inherited fields
@@ -66,16 +26,45 @@ 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
+
+        # A list of Ruby keywords.
+        #
+        # @api private
+        RUBY_KEYWORDS = [:class, :module, :def, :undef, :begin, :rescue, :ensure, :end, :if, :unless, :then, :elsif, :else, :case, :when, :while, :until, :for, :break, :next, :redo, :retry, :in, :do, :return, :yield, :super, :self, :nil, :true, :false, :and, :or, :not, :alias, :defined?, :BEGIN, :END, :__LINE__, :__FILE__]
+
+        # A list of GraphQL-Ruby keywords.
+        #
+        # @api private
+        GRAPHQL_RUBY_KEYWORDS = [:context, :object, :raw_value]
+
+        # A list of field names that we should advise users to pick a different
+        # resolve method name.
+        #
+        # @api private
+        CONFLICT_FIELD_NAMES = Set.new(GRAPHQL_RUBY_KEYWORDS + RUBY_KEYWORDS + Object.instance_methods)
+
         # 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)
+        def add_field(field_defn, method_conflict_warning: field_defn.method_conflict_warning?)
+          # Check that `field_defn.original_name` equals `resolver_method` and `method_sym` --
+          # that shows that no override value was given manually.
+          if method_conflict_warning && CONFLICT_FIELD_NAMES.include?(field_defn.resolver_method) && field_defn.original_name == field_defn.resolver_method && field_defn.original_name == field_defn.method_sym
+            warn(conflict_field_name_warning(field_defn))
           end
+          own_fields[field_defn.name] = field_defn
           nil
         end
 
@@ -83,18 +72,19 @@ module GraphQL
         def field_class(new_field_class = nil)
           if new_field_class
             @field_class = new_field_class
-          elsif @field_class
+          elsif defined?(@field_class) && @field_class
             @field_class
-          elsif self.is_a?(Class)
-            superclass.respond_to?(:field_class) ? superclass.field_class : GraphQL::Schema::Field
           else
-            ancestor = ancestors[1..-1].find { |a| a.respond_to?(:field_class) && a.field_class }
-            ancestor ? ancestor.field_class : GraphQL::Schema::Field
+            find_inherited_value(:field_class, GraphQL::Schema::Field)
           end
         end
 
-        def global_id_field(field_name)
-          field field_name, "ID", null: false, resolve: GraphQL::Relay::GlobalIdResolve.new(type: self)
+        def global_id_field(field_name, **kwargs)
+          id_resolver = GraphQL::Relay::GlobalIdResolve.new(type: self)
+          field field_name, "ID", **kwargs, 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
@@ -103,26 +93,11 @@ module GraphQL
         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
+
+        # @param [GraphQL::Schema::Field]
+        # @return [String] A warning to give when this field definition might conflict with a built-in method
+        def conflict_field_name_warning(field_defn)
+          "#{self.graphql_name}'s `field :#{field_defn.original_name}` conflicts with a built-in method, use `resolver_method:` to pick a different resolver method for this field (for example, `resolver_method: :resolve_#{field_defn.resolver_method}` and `def resolve_#{field_defn.resolver_method}`). Or use `method_conflict_warning: false` to suppress this warning."
         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/has_unresolved_type_error.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      # Set up a type-specific error to make debugging & bug tracker integration better
+      module HasUnresolvedTypeError
+        private
+        def add_unresolved_type_error(child_class)
+          child_class.const_set(:UnresolvedTypeError, Class.new(GraphQL::UnresolvedTypeError))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Member
+      module HasValidators
+        include Schema::FindInheritedValue::EmptyObjects
+
+        # Build {GraphQL::Schema::Validator}s based on the given configuration
+        # and use them for this schema member
+        # @param validation_config [Hash{Symbol => Hash}]
+        # @return [void]
+        def validates(validation_config)
+          new_validators = GraphQL::Schema::Validator.from_config(self, validation_config)
+          @own_validators ||= []
+          @own_validators.concat(new_validators)
+          nil
+        end
+
+        # @return [Array<GraphQL::Schema::Validator>]
+        def validators
+          own_validators = @own_validators || EMPTY_ARRAY
+          if self.is_a?(Class) && superclass.respond_to?(:validators) && (inherited_validators = superclass.validators).any?
+            inherited_validators + own_validators
+          else
+            own_validators
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../object.rb
 
 module GraphQL
   class Schema
@@ -27,7 +26,13 @@ module GraphQL
             # If it has a wrapper, apply it
             wrapper_class = root_type.metadata[:type_class]
             if wrapper_class
-              new_root_value = wrapper_class.new(query.root_value, query.context)
+              new_root_value = wrapper_class.authorized_new(query.root_value, query.context)
+              new_root_value = query.schema.sync_lazy(new_root_value)
+              if new_root_value.nil?
+                # This is definitely a hack,
+                # but we need some way to tell execute.rb not to run.
+                query.context[:__root_unauthorized] = true
+              end
               query.root_value = new_root_value
             end
           end
@@ -72,39 +77,50 @@ module GraphQL
 
           def call(obj, args, ctx)
             result = @inner_resolve.call(obj, args, ctx)
-            if ctx.schema.lazy?(result)
-              # Wrap it later
-              result
-            elsif ctx.skip == result
+            if ctx.skip == result || ctx.schema.lazy?(result) || result.nil? || execution_errors?(result) || ctx.wrapped_object
               result
             else
-              proxy_to_depth(result, @list_depth, @inner_return_type, ctx)
+              ctx.wrapped_object = true
+              proxy_to_depth(result, @list_depth, ctx)
             end
           end
 
           private
 
-          def proxy_to_depth(obj, depth, type, ctx)
-            if obj.nil?
-              obj
-            elsif depth > 0
-              obj.map { |inner_obj| proxy_to_depth(inner_obj, depth - 1, type, ctx) }
+          def execution_errors?(result)
+            result.is_a?(GraphQL::ExecutionError) ||
+              (result.is_a?(Array) && result.any? && result.all? { |v| v.is_a?(GraphQL::ExecutionError) })
+          end
+
+          def proxy_to_depth(inner_obj, depth, ctx)
+            if depth > 0
+              inner_obj.map { |i| proxy_to_depth(i, depth - 1, ctx) }
             else
-              concrete_type = case type
-              when GraphQL::UnionType, GraphQL::InterfaceType
-                ctx.query.resolve_type(type, obj)
-              when GraphQL::ObjectType
-                type
-              else
-                raise "unexpected proxying type #{type} for #{obj} at #{ctx.owner_type}.#{ctx.field.name}"
-              end
+              ctx.schema.after_lazy(inner_obj) do |inner_obj|
+                if inner_obj.nil?
+                  # For lists with nil, we need another nil check here
+                  nil
+                else
+                  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
+                    @inner_return_type
+                  else
+                    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.new(obj, query_ctx)
-              else
-                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
             end
           end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      module RelayShortcuts
+        def edge_type_class(new_edge_type_class = nil)
+          if new_edge_type_class
+            @edge_type_class = new_edge_type_class
+          else
+            @edge_type_class || find_inherited_value(:edge_type_class, Types::Relay::BaseEdge)
+          end
+        end
+
+        def connection_type_class(new_connection_type_class = nil)
+          if new_connection_type_class
+            @connection_type_class = new_connection_type_class
+          else
+            @connection_type_class || find_inherited_value(:connection_type_class, Types::Relay::BaseConnection)
+          end
+        end
+
+        def edge_type
+          @edge_type ||= begin
+            edge_name = self.graphql_name + "Edge"
+            node_type_class = self
+            Class.new(edge_type_class) do
+              graphql_name(edge_name)
+              node_type(node_type_class)
+            end
+          end
+        end
+
+        def connection_type
+          @connection_type ||= begin
+            conn_name = self.graphql_name + "Connection"
+            edge_type_class = self.edge_type
+            Class.new(connection_type_class) do
+              graphql_name(conn_name)
+              edge_type(edge_type_class)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      module Scoped
+        # This is called when a field has `scope: true`.
+        # The field's return type class receives this call.
+        #
+        # By default, it's a no-op. Override it to scope your objects.
+        #
+        # @param items [Object] Some list-like object (eg, Array, ActiveRecord::Relation)
+        # @param context [GraphQL::Query::Context]
+        # @return [Object] Another list-like object, scoped to the current context
+        def scope_items(items, context)
+          items
+        end
+      end
+    end
+  end
+end

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

@@ -6,12 +6,12 @@ module GraphQL
       module TypeSystemHelpers
         # @return [Schema::NonNull] Make a non-null-type representation of this type
         def to_non_null_type
-          GraphQL::Schema::NonNull.new(self)
+          @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)
+          @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.
@@ -24,9 +24,13 @@ module GraphQL
           false
         end
 
+        def to_type_signature
+          graphql_name
+        end
+
         # @return [GraphQL::TypeKinds::TypeKind]
         def kind
-          raise NotImplementedError
+          raise GraphQL::RequiredImplementationMissingError, "No `.kind` defined for #{self}"
         end
       end
     end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      module ValidatesInput
+        def valid_input?(val, ctx)
+          validate_input(val, ctx).valid?
+        end
+
+        def validate_input(val, ctx)
+          if val.nil?
+            GraphQL::Query::InputValidationResult.new
+          else
+            validate_non_null_input(val, ctx)
+          end
+        end
+
+        def valid_isolated_input?(v)
+          valid_input?(v, GraphQL::Query::NullContext)
+        end
+
+        def coerce_isolated_input(v)
+          coerce_input(v, GraphQL::Query::NullContext)
+        end
+
+        def coerce_isolated_result(v)
+          coerce_result(v, GraphQL::Query::NullContext)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/member.rb

@@ -3,21 +3,37 @@ 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_ast_node'
+require 'graphql/schema/member/has_directives'
+require 'graphql/schema/member/has_deprecation_reason'
+require 'graphql/schema/member/has_path'
+require 'graphql/schema/member/has_unresolved_type_error'
+require 'graphql/schema/member/has_validators'
+require 'graphql/schema/member/relay_shortcuts'
+require 'graphql/schema/member/scoped'
 require 'graphql/schema/member/type_system_helpers'
+require 'graphql/schema/member/validates_input'
 require "graphql/relay/type_extensions"
 
 module GraphQL
-  # The base class for things that make up the schema,
-  # eg objects, enums, scalars.
-  #
-  # @api private
   class Schema
+    # The base class for things that make up the schema,
+    # eg objects, enums, scalars.
+    #
+    # @api private
     class Member
       include GraphQLTypeNames
       extend CachedGraphQLDefinition
       extend GraphQL::Relay::TypeExtensions
       extend BaseDSLMethods
+      extend BaseDSLMethods::ConfigurationExtension
+      introspection(false)
       extend TypeSystemHelpers
+      extend Scoped
+      extend RelayShortcuts
+      extend HasPath
+      extend HasAstNode
+      extend HasDirectives
     end
   end
 end

data/lib/graphql/schema/middleware_chain.rb

@@ -71,7 +71,7 @@ module GraphQL
 
       def wrap(callable)
         if BackwardsCompatibility.get_arity(callable) == 6
-          warn("Middleware that takes a next_middleware parameter is deprecated (#{callable.inspect}); instead, accept a block and use yield.")
+          GraphQL::Deprecation.warn("Middleware that takes a next_middleware parameter is deprecated (#{callable.inspect}); instead, accept a block and use yield.")
           MiddlewareWrapper.new(callable)
         else
           callable

data/lib/graphql/schema/mutation.rb

@@ -17,7 +17,7 @@ module GraphQL
     #    argument :post_id, ID, required: true
     #
     #    field :comment, Types::Comment, null: true
-    #    field :error_messages, [String], null: false
+    #    field :errors, [String], null: false
     #
     #    def resolve(body:, post_id:)
     #      post = Post.find(post_id)
@@ -60,77 +60,33 @@ 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?
+        def field(*args, **kwargs, &block)
+          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
+        def visible?(context)
+          true
         end
 
-        alias :type :payload_type
-        alias :type_expr :payload_type
-
-        # 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
-
-        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
+        private
 
-        # 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)
+        def conflict_field_name_warning(field_defn)
+          "#{self.graphql_name}'s `field :#{field_defn.name}` conflicts with a built-in method, use `hash_key:` or `method:` to pick a different resolve behavior for this field (for example, `hash_key: :#{field_defn.resolver_method}_value`, and modify the return hash). Or use `method_conflict_warning: false` to suppress this warning."
         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