graphql 1.9.18 → 1.13.24

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

@@ -3,40 +3,51 @@
 module GraphQL
   class Schema
     class Member
-      # Shared code for Object and Interface
+      # Shared code for Objects, Interfaces, Mutations, Subscriptions
       module HasFields
         # 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
-        def fields
+        def fields(context = GraphQL::Query::NullContext)
+          warden = Warden.from_context(context)
+          is_object = self.respond_to?(:kind) && self.kind.object?
           # Local overrides take precedence over inherited fields
-          all_fields = {}
-          ancestors.reverse_each do |ancestor|
-            if ancestor.respond_to?(:own_fields)
-              all_fields.merge!(ancestor.own_fields)
+          visible_fields = {}
+          for ancestor in ancestors
+            if ancestor.respond_to?(:own_fields) &&
+                (is_object ? visible_interface_implementation?(ancestor, context, warden) : true)
+
+              ancestor.own_fields.each do |field_name, fields_entry|
+                # Choose the most local definition that passes `.visible?` --
+                # stop checking for fields by name once one has been found.
+                if !visible_fields.key?(field_name) && (f = Warden.visible_entry?(:visible_field?, fields_entry, context, warden))
+                  visible_fields[field_name] = f
+                end
+              end
             end
           end
-          all_fields
+          visible_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
+        def get_field(field_name, context = GraphQL::Query::NullContext)
+          warden = Warden.from_context(context)
+          is_object = self.respond_to?(:kind) && self.kind.object?
+          for ancestor in ancestors
+            if ancestor.respond_to?(:own_fields) &&
+                (is_object ? visible_interface_implementation?(ancestor, context, warden) : true) &&
+                (f_entry = ancestor.own_fields[field_name]) &&
+                (f = Warden.visible_entry?(:visible_field?, f_entry, context, warden))
+              return f
             end
-            nil
           end
+          nil
         end
 
         # A list of Ruby keywords.
@@ -47,22 +58,36 @@ module GraphQL
         # A list of GraphQL-Ruby keywords.
         #
         # @api private
-        GRAPHQL_RUBY_KEYWORDS = [:context, :object, :method]
+        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)
+        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.
         # @param field_defn [GraphQL::Schema::Field]
         # @return [void]
-        def add_field(field_defn)
-          if CONFLICT_FIELD_NAMES.include?(field_defn.original_name) && field_defn.original_name == field_defn.resolver_method
-            warn "#{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.original_name}` and `def resolve_#{field_defn.original_name}`)"
+        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
+          prev_defn = own_fields[field_defn.name]
+
+          case prev_defn
+          when nil
+            own_fields[field_defn.name] = field_defn
+          when Array
+            prev_defn << field_defn
+          when GraphQL::Schema::Field
+            own_fields[field_defn.name] = [prev_defn, field_defn]
+          else
+            raise "Invariant: unexpected previous field definition for #{field_defn.name.inspect}: #{prev_defn.inspect}"
           end
-          own_fields[field_defn.name] = field_defn
+
           nil
         end
 
@@ -70,28 +95,68 @@ 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)
+        def global_id_field(field_name, **kwargs)
           id_resolver = GraphQL::Relay::GlobalIdResolve.new(type: self)
-          field field_name, "ID", null: false
+          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
+        # @return [Hash<String => GraphQL::Schema::Field, Array<GraphQL::Schema::Field>>] Fields defined on this class _specifically_, not parent classes
         def own_fields
           @own_fields ||= {}
         end
+
+        def all_field_definitions
+          all_fields = {}
+          ancestors.reverse_each do |ancestor|
+            if ancestor.respond_to?(:own_fields)
+              all_fields.merge!(ancestor.own_fields)
+            end
+          end
+          all_fields = all_fields.values
+          all_fields.flatten!
+          all_fields
+        end
+
+        private
+
+        # If `type` is an interface, and `self` has a type membership for `type`, then make sure it's visible.
+        def visible_interface_implementation?(type, context, warden)
+          if type.respond_to?(:kind) && type.kind.interface?
+            implements_this_interface = false
+            implementation_is_visible = false
+            warden.interface_type_memberships(self, context).each do |tm|
+              if tm.abstract_type == type
+                implements_this_interface ||= true
+                if warden.visible_type_membership?(tm, context)
+                  implementation_is_visible = true
+                  break
+                end
+              end
+            end
+            # It's possible this interface came by way of `include` in another interface which this
+            # object type _does_ implement, and that's ok
+            implements_this_interface ? implementation_is_visible : true
+          else
+            # If there's no implementation, then we're looking at Ruby-style inheritance instead
+            true
+          end
+        end
+
+        # @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
   end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      module HasInterfaces
+        def implements(*new_interfaces, **options)
+          new_memberships = []
+          new_interfaces.each do |int|
+            if int.is_a?(Module)
+              unless int.include?(GraphQL::Schema::Interface)
+                raise "#{int} cannot be implemented since it's not a GraphQL Interface. Use `include` for plain Ruby modules."
+              end
+
+              new_memberships << int.type_membership_class.new(int, self, **options)
+
+              # Include the methods here,
+              # `.fields` will use the inheritance chain
+              # to find inherited fields
+              include(int)
+
+              # If this interface has interfaces of its own, add those, too
+              int.interfaces.each do |next_interface|
+                implements(next_interface)
+              end
+            elsif int.is_a?(GraphQL::InterfaceType)
+              new_memberships << int.type_membership_class.new(int, self, **options)
+            elsif int.is_a?(String) || int.is_a?(GraphQL::Schema::LateBoundType)
+              if options.any?
+                raise ArgumentError, "`implements(...)` doesn't support options with late-loaded types yet. Remove #{options} and open an issue to request this feature."
+              end
+              new_memberships << int
+            else
+              raise ArgumentError, "Unexpected interface definition (expected module): #{int} (#{int.class})"
+            end
+          end
+
+          # Remove any String or late-bound interfaces which are being replaced
+          own_interface_type_memberships.reject! { |old_i_m|
+            if !(old_i_m.respond_to?(:abstract_type) && old_i_m.abstract_type.is_a?(Module))
+              old_int_type = old_i_m.respond_to?(:abstract_type) ? old_i_m.abstract_type : old_i_m
+              old_name = Schema::Member::BuildType.to_type_name(old_int_type)
+
+              new_memberships.any? { |new_i_m|
+                new_int_type = new_i_m.respond_to?(:abstract_type) ? new_i_m.abstract_type : new_i_m
+                new_name = Schema::Member::BuildType.to_type_name(new_int_type)
+
+                new_name == old_name
+              }
+            end
+          }
+          own_interface_type_memberships.concat(new_memberships)
+        end
+
+        def own_interface_type_memberships
+          @own_interface_type_memberships ||= []
+        end
+
+        def interface_type_memberships
+          own_tms = own_interface_type_memberships
+          if (self.is_a?(Class) && superclass.respond_to?(:interface_type_memberships))
+            inherited_tms = superclass.interface_type_memberships
+            if inherited_tms.size > 0
+              own_tms + inherited_tms
+            else
+              own_tms
+            end
+          else
+            own_tms
+          end
+        end
+
+        # param context [Query::Context] If omitted, skip filtering.
+        def interfaces(context = GraphQL::Query::NullContext)
+          warden = Warden.from_context(context)
+          visible_interfaces = []
+          own_interface_type_memberships.each do |type_membership|
+            # During initialization, `type_memberships` can hold late-bound types
+            case type_membership
+            when String, Schema::LateBoundType
+              visible_interfaces << type_membership
+            when Schema::TypeMembership
+              if warden.visible_type_membership?(type_membership, context)
+                visible_interfaces << type_membership.abstract_type
+              end
+            else
+              raise "Invariant: Unexpected type_membership #{type_membership.class}: #{type_membership.inspect}"
+            end
+          end
+
+          if self.is_a?(Class) && superclass <= GraphQL::Schema::Object
+            visible_interfaces.concat(superclass.interfaces(context))
+          end
+
+          visible_interfaces
+        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

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.
@@ -30,7 +30,7 @@ module GraphQL
 
         # @return [GraphQL::TypeKinds::TypeKind]
         def kind
-          raise GraphQL::RequiredImplementationMissingError
+          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, max_errors: nil)
+          if val.nil?
+            GraphQL::Query::InputValidationResult.new
+          else
+            validate_non_null_input(val, ctx, max_errors: max_errors) || Query::InputValidationResult::VALID
+          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,10 +3,17 @@ 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_interfaces'
 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
@@ -20,10 +27,14 @@ module GraphQL
       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

@@ -78,6 +78,10 @@ module GraphQL
 
         private
 
+        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
+
         # Override this to attach self as `mutation`
         def generate_payload_type
           payload_class = super

data/lib/graphql/schema/non_null.rb

@@ -6,8 +6,12 @@ module GraphQL
     # Wraps a {Schema::Member} when it is required.
     # @see {Schema::Member::TypeSystemHelpers#to_non_null_type}
     class NonNull < GraphQL::Schema::Wrapper
+      include Schema::Member::ValidatesInput
+
+      prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
+
       def to_graphql
-        @of_type.graphql_definition.to_non_null_type
+        @of_type.graphql_definition(silence_deprecation_warning: true).to_non_null_type
       end
 
        # @return [GraphQL::TypeKinds::NON_NULL]
@@ -32,6 +36,38 @@ module GraphQL
       def inspect
         "#<#{self.class.name} @of_type=#{@of_type.inspect}>"
       end
+
+      def validate_input(value, ctx, max_errors: nil)
+        if value.nil?
+          result = GraphQL::Query::InputValidationResult.new
+          result.add_problem("Expected value to not be null")
+          result
+        else
+          of_type.validate_input(value, ctx, max_errors: max_errors)
+        end
+      end
+
+      # This is for introspection, where it's expected the name will be `null`
+      def graphql_name
+        nil
+      end
+
+      def coerce_input(value, ctx)
+        # `.validate_input` above is used for variables, but this method is used for arguments
+        if value.nil?
+          raise GraphQL::ExecutionError, "`null` is not a valid input for `#{to_type_signature}`, please provide a value for this argument."
+        end
+        of_type.coerce_input(value, ctx)
+      end
+
+      def coerce_result(value, ctx)
+        of_type.coerce_result(value, ctx)
+      end
+
+      # This is for implementing introspection
+      def description
+        nil
+      end
     end
   end
 end

data/lib/graphql/schema/object.rb

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
 
+require "graphql/query/null_context"
+
 module GraphQL
   class Schema
     class Object < GraphQL::Schema::Member
       extend GraphQL::Schema::Member::AcceptsDefinition
       extend GraphQL::Schema::Member::HasFields
+      extend GraphQL::Schema::Member::HasInterfaces
 
       # @return [Object] the application object this type is wrapping
       attr_reader :object
@@ -12,6 +15,17 @@ module GraphQL
       # @return [GraphQL::Query::Context] the context instance for this query
       attr_reader :context
 
+      # @return [GraphQL::Dataloader]
+      def dataloader
+        context.dataloader
+      end
+
+      # Call this in a field method to return a value that should be returned to the client
+      # without any further handling by GraphQL.
+      def raw_value(obj)
+        GraphQL::Execution::Interpreter::RawValue.new(obj)
+      end
+
       class << self
         # This is protected so that we can be sure callers use the public method, {.authorized_new}
         # @see authorized_new to make instances
@@ -35,14 +49,28 @@ module GraphQL
         # @return [GraphQL::Schema::Object, GraphQL::Execution::Lazy]
         # @raise [GraphQL::UnauthorizedError] if the user-provided hook returns `false`
         def authorized_new(object, context)
-          auth_val = context.query.with_error_handling do
-            begin
-              authorized?(object, context)
-            rescue GraphQL::UnauthorizedError => err
-              context.schema.unauthorized_object(err)
+          trace_payload = { context: context, type: self, object: object, path: context[:current_path] }
+
+          maybe_lazy_auth_val = context.query.trace("authorized", trace_payload) do
+            context.query.with_error_handling do
+              begin
+                authorized?(object, context)
+              rescue GraphQL::UnauthorizedError => err
+                context.schema.unauthorized_object(err)
+              end
             end
           end
 
+          auth_val = if context.schema.lazy?(maybe_lazy_auth_val)
+            GraphQL::Execution::Lazy.new do
+              context.query.trace("authorized_lazy", trace_payload) do
+                context.schema.sync_lazy(maybe_lazy_auth_val)
+              end
+            end
+          else
+            maybe_lazy_auth_val
+          end
+
           context.schema.after_lazy(auth_val) do |is_authorized|
             if is_authorized
               self.new(object, context)
@@ -57,13 +85,9 @@ module GraphQL
                 else
                   nil
                 end
-              # rescue GraphQL::ExecutionError => err
-              #   err
               end
             end
           end
-        # rescue GraphQL::ExecutionError => err
-        #   err
         end
       end
 
@@ -73,37 +97,23 @@ module GraphQL
       end
 
       class << self
-        def implements(*new_interfaces)
-          new_interfaces.each do |int|
-            if int.is_a?(Module)
-              unless int.include?(GraphQL::Schema::Interface)
-                raise "#{int} cannot be implemented since it's not a GraphQL Interface. Use `include` for plain Ruby modules."
-              end
-
-              # Include the methods here,
-              # `.fields` will use the inheritance chain
-              # to find inherited fields
-              include(int)
-            end
-          end
-          own_interfaces.concat(new_interfaces)
+        # Set up a type-specific invalid null error to use when this object's non-null fields wrongly return `nil`.
+        # It should help with debugging and bug tracker integrations.
+        def inherited(child_class)
+          child_class.const_set(:InvalidNullError, GraphQL::InvalidNullError.subclass_for(child_class))
+          super
         end
 
-        def interfaces
-          own_interfaces + (superclass <= GraphQL::Schema::Object ? superclass.interfaces : [])
-        end
-
-        def own_interfaces
-          @own_interfaces ||= []
-        end
-
-        # Include legacy-style interfaces, too
-        def fields
+        # @return [Hash<String => GraphQL::Schema::Field>] All of this object's fields, indexed by name
+        # @see get_field A faster way to find one field by name ({#fields} merges hashes of inherited fields; {#get_field} just looks up one field.)
+        def fields(context = GraphQL::Query::NullContext)
           all_fields = super
+          # This adds fields from legacy-style interfaces only.
+          # Multi-fields are not supported here.
           interfaces.each do |int|
             if int.is_a?(GraphQL::InterfaceType)
               int_f = {}
-              int.fields.each do |name, legacy_field|
+              int.fields.each do |name, legacy_field| # rubocop:disable Development/ContextIsPassedCop -- legacy-related
                 int_f[name] = field_class.from_options(name, field: legacy_field)
               end
               all_fields = int_f.merge(all_fields)
@@ -112,17 +122,20 @@ module GraphQL
           all_fields
         end
 
+        prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
+
         # @return [GraphQL::ObjectType]
         def to_graphql
           obj_type = GraphQL::ObjectType.new
           obj_type.name = graphql_name
           obj_type.description = description
-          obj_type.interfaces = interfaces
+          obj_type.structural_interface_type_memberships = interface_type_memberships
           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
+          obj_type.ast_node = ast_node
+          fields.each do |field_name, field_inst| # rubocop:disable Development/ContextIsPassedCop -- legacy-related
+            field_defn = field_inst.to_graphql(silence_deprecation_warning: true)
+            obj_type.fields[field_defn.name] = field_defn # rubocop:disable Development/ContextIsPassedCop -- legacy-related
           end
 
           obj_type.metadata[:type_class] = self