graphql 2.0.13 → 2.3.10

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

@@ -14,42 +14,6 @@ module GraphQL
           field_defn
         end
 
-        # @return [Hash<String => GraphQL::Schema::Field>] Fields on this object, keyed by name, including inherited 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
-          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
-          visible_fields
-        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
-          end
-          nil
-        end
-
         # A list of Ruby keywords.
         #
         # @api private
@@ -72,7 +36,12 @@ module GraphQL
         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 && field_defn.hash_key.nil? && field_defn.dig_keys.nil?
+          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 &&
+              field_defn.hash_key == NOT_CONFIGURED &&
+              field_defn.dig_keys.nil?
             warn(conflict_field_name_warning(field_defn))
           end
           prev_defn = own_fields[field_defn.name]
@@ -127,14 +96,107 @@ module GraphQL
           all_fields
         end
 
+        module InterfaceMethods
+          def get_field(field_name, context = GraphQL::Query::NullContext.instance)
+            warden = Warden.from_context(context)
+            skip_visible = context.respond_to?(:types) && context.types.is_a?(GraphQL::Schema::Subset)
+            for ancestor in ancestors
+              if ancestor.respond_to?(:own_fields) &&
+                  (f_entry = ancestor.own_fields[field_name]) &&
+                  (skip_visible || (f_entry = Warden.visible_entry?(:visible_field?, f_entry, context, warden)))
+                return f_entry
+              end
+            end
+            nil
+          end
+
+          # @return [Hash<String => GraphQL::Schema::Field>] Fields on this object, keyed by name, including inherited fields
+          def fields(context = GraphQL::Query::NullContext.instance)
+            warden = Warden.from_context(context)
+            # Local overrides take precedence over inherited fields
+            visible_fields = {}
+            for ancestor in ancestors
+              if ancestor.respond_to?(:own_fields)
+                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
+            visible_fields
+          end
+        end
+
+        module ObjectMethods
+          def get_field(field_name, context = GraphQL::Query::NullContext.instance)
+            # Objects need to check that the interface implementation is visible, too
+            warden = Warden.from_context(context)
+            ancs = ancestors
+            skip_visible = context.respond_to?(:types) && context.types.is_a?(GraphQL::Schema::Subset)
+            i = 0
+            while (ancestor = ancs[i])
+              if ancestor.respond_to?(:own_fields) &&
+                  visible_interface_implementation?(ancestor, context, warden) &&
+                  (f_entry = ancestor.own_fields[field_name]) &&
+                  (skip_visible || (f_entry = Warden.visible_entry?(:visible_field?, f_entry, context, warden)))
+                return f_entry
+              end
+              i += 1
+            end
+            nil
+          end
+
+          # @return [Hash<String => GraphQL::Schema::Field>] Fields on this object, keyed by name, including inherited fields
+          def fields(context = GraphQL::Query::NullContext.instance)
+            # Objects need to check that the interface implementation is visible, too
+            warden = Warden.from_context(context)
+            # Local overrides take precedence over inherited fields
+            visible_fields = {}
+            for ancestor in ancestors
+              if ancestor.respond_to?(:own_fields) && visible_interface_implementation?(ancestor, context, warden)
+                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
+            visible_fields
+          end
+        end
+
+        def self.included(child_class)
+          # Included in an interface definition methods module
+          child_class.include(InterfaceMethods)
+          super
+        end
+
+        def self.extended(child_class)
+          child_class.extend(ObjectMethods)
+          super
+        end
+
         private
 
+        def inherited(subclass)
+          super
+          subclass.class_eval do
+            @own_fields ||= nil
+            @field_class ||= nil
+          end
+        end
+
         # 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
-            interface_type_memberships.each do |tm|
+            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)

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

@@ -55,32 +55,87 @@ module GraphQL
         end
 
         def interface_type_memberships
-          own_interface_type_memberships + ((self.is_a?(Class) && superclass.respond_to?(:interface_type_memberships)) ? superclass.interface_type_memberships : [])
+          own_interface_type_memberships
+        end
+
+        module ClassConfigured
+          # This combination of extended -> inherited -> extended
+          # means that the base class (`Schema::Object`) *won't*
+          # have the superclass-related code in `InheritedInterfaces`,
+          # but child classes of `Schema::Object` will have it.
+          # That way, we don't need a `superclass.respond_to?(...)` check.
+          def inherited(child_class)
+            super
+            child_class.extend(InheritedInterfaces)
+          end
+
+          module InheritedInterfaces
+            def interfaces(context = GraphQL::Query::NullContext.instance)
+              visible_interfaces = super
+              inherited_interfaces = superclass.interfaces(context)
+              if visible_interfaces.any?
+                if inherited_interfaces.any?
+                  visible_interfaces.concat(inherited_interfaces)
+                  visible_interfaces.uniq!
+                end
+                visible_interfaces
+              elsif inherited_interfaces.any?
+                inherited_interfaces
+              else
+                EmptyObjects::EMPTY_ARRAY
+              end
+            end
+
+            def interface_type_memberships
+              own_tms = super
+              inherited_tms = superclass.interface_type_memberships
+              if inherited_tms.size > 0
+                own_tms + inherited_tms
+              else
+                own_tms
+              end
+            end
+          end
         end
 
         # param context [Query::Context] If omitted, skip filtering.
-        def interfaces(context = GraphQL::Query::NullContext)
+        def interfaces(context = GraphQL::Query::NullContext.instance)
           warden = Warden.from_context(context)
-          visible_interfaces = []
+          visible_interfaces = nil
           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 ||= []
                 visible_interfaces << type_membership.abstract_type
               end
+            when String, Schema::LateBoundType
+              # During initialization, `type_memberships` can hold late-bound types
+              visible_interfaces ||= []
+              visible_interfaces << type_membership
             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))
+          if visible_interfaces
+            visible_interfaces.uniq!
+            visible_interfaces
+          else
+            EmptyObjects::EMPTY_ARRAY
           end
+        end
+
+        private
 
-          visible_interfaces.uniq
+        def self.extended(child_class)
+          child_class.extend(ClassConfigured)
+        end
+
+        def inherited(subclass)
+          super
+          subclass.class_eval do
+            @own_interface_type_memberships ||= nil
+          end
         end
       end
     end

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

@@ -7,7 +7,11 @@ module GraphQL
       module HasUnresolvedTypeError
         private
         def add_unresolved_type_error(child_class)
-          child_class.const_set(:UnresolvedTypeError, Class.new(GraphQL::UnresolvedTypeError))
+          if child_class.name # Don't set this for anonymous classes
+            child_class.const_set(:UnresolvedTypeError, Class.new(GraphQL::UnresolvedTypeError))
+          else
+            child_class.const_set(:UnresolvedTypeError, UnresolvedTypeError)
+          end
         end
       end
     end

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

@@ -3,7 +3,7 @@ module GraphQL
   class Schema
     class Member
       module HasValidators
-        include Schema::FindInheritedValue::EmptyObjects
+        include GraphQL::EmptyObjects
 
         # Build {GraphQL::Schema::Validator}s based on the given configuration
         # and use them for this schema member
@@ -18,12 +18,38 @@ module GraphQL
 
         # @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
+          @own_validators || EMPTY_ARRAY
+        end
+
+        module ClassConfigured
+          def inherited(child_cls)
+            super
+            child_cls.extend(ClassValidators)
           end
+
+          module ClassValidators
+            include GraphQL::EmptyObjects
+
+            def validators
+              inherited_validators = superclass.validators
+              if inherited_validators.any?
+                if @own_validators.nil?
+                  inherited_validators
+                else
+                  inherited_validators + @own_validators
+                end
+              elsif @own_validators.nil?
+                EMPTY_ARRAY
+              else
+                @own_validators
+              end
+            end
+          end
+        end
+
+        def self.extended(child_cls)
+          super
+          child_cls.extend(ClassConfigured)
         end
       end
     end

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

@@ -6,6 +6,7 @@ module GraphQL
       module RelayShortcuts
         def edge_type_class(new_edge_type_class = nil)
           if new_edge_type_class
+            initialize_relay_metadata
             @edge_type_class = new_edge_type_class
           else
             # Don't call `ancestor.edge_type_class`
@@ -22,6 +23,7 @@ module GraphQL
 
         def connection_type_class(new_connection_type_class = nil)
           if new_connection_type_class
+            initialize_relay_metadata
             @connection_type_class = new_connection_type_class
           else
             # Don't call `ancestor.connection_type_class`
@@ -37,6 +39,7 @@ module GraphQL
         end
 
         def edge_type
+          initialize_relay_metadata
           @edge_type ||= begin
             edge_name = self.graphql_name + "Edge"
             node_type_class = self
@@ -48,6 +51,7 @@ module GraphQL
         end
 
         def connection_type
+          initialize_relay_metadata
           @connection_type ||= begin
             conn_name = self.graphql_name + "Connection"
             edge_type_class = self.edge_type
@@ -67,6 +71,21 @@ module GraphQL
         def configured_edge_type_class
           @edge_type_class
         end
+
+        attr_writer :edge_type, :connection_type, :connection_type_class, :edge_type_class
+
+        private
+
+        # If one of these values is accessed, initialize all the instance variables to retain
+        # a consistent object shape.
+        def initialize_relay_metadata
+          if !defined?(@connection_type)
+            @connection_type = nil
+            @edge_type = nil
+            @connection_type_class = nil
+            @edge_type_class = nil
+          end
+        end
       end
     end
   end

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

@@ -15,6 +15,25 @@ module GraphQL
         def scope_items(items, context)
           items
         end
+
+        def reauthorize_scoped_objects(new_value = nil)
+          if new_value.nil?
+            if @reauthorize_scoped_objects != nil
+              @reauthorize_scoped_objects
+            else
+              find_inherited_value(:reauthorize_scoped_objects, true)
+            end
+          else
+            @reauthorize_scoped_objects = new_value
+          end
+        end
+
+        def inherited(subclass)
+          super
+          subclass.class_eval do
+            @reauthorize_scoped_objects = nil
+          end
+        end
       end
     end
   end

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

@@ -4,6 +4,12 @@ module GraphQL
   class Schema
     class Member
       module TypeSystemHelpers
+        def initialize(...)
+          super
+          @to_non_null_type ||= nil
+          @to_list_type ||= nil
+        end
+
         # @return [Schema::NonNull] Make a non-null-type representation of this type
         def to_non_null_type
           @to_non_null_type ||= GraphQL::Schema::NonNull.new(self)
@@ -32,6 +38,16 @@ module GraphQL
         def kind
           raise GraphQL::RequiredImplementationMissingError, "No `.kind` defined for #{self}"
         end
+
+        private
+
+        def inherited(subclass)
+          subclass.class_eval do
+            @to_non_null_type ||= nil
+            @to_list_type ||= nil
+          end
+          super
+        end
       end
     end
   end

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

@@ -17,15 +17,15 @@ module GraphQL
         end
 
         def valid_isolated_input?(v)
-          valid_input?(v, GraphQL::Query::NullContext)
+          valid_input?(v, GraphQL::Query::NullContext.instance)
         end
 
         def coerce_isolated_input(v)
-          coerce_input(v, GraphQL::Query::NullContext)
+          coerce_input(v, GraphQL::Query::NullContext.instance)
         end
 
         def coerce_isolated_result(v)
-          coerce_result(v, GraphQL::Query::NullContext)
+          coerce_result(v, GraphQL::Query::NullContext.instance)
         end
       end
     end

data/lib/graphql/schema/mutation.rb

@@ -62,6 +62,13 @@ module GraphQL
       extend GraphQL::Schema::Member::HasFields
       extend GraphQL::Schema::Resolver::HasPayloadType
 
+      # @api private
+      def call_resolve(_args_hash)
+        # Clear any cached values from `loads` or authorization:
+        dataloader.clear_cache
+        super
+      end
+
       class << self
         def visible?(context)
           true

data/lib/graphql/schema/object.rb

@@ -30,6 +30,15 @@ module GraphQL
         # @see authorized_new to make instances
         protected :new
 
+        def wrap_scoped(object, context)
+          scoped_new(object, context)
+        end
+
+        # This is called by the runtime to return an object to call methods on.
+        def wrap(object, context)
+          authorized_new(object, context)
+        end
+
         # Make a new instance of this type _if_ the auth check passes,
         # otherwise, raise an error.
         #
@@ -48,9 +57,7 @@ module GraphQL
         # @return [GraphQL::Schema::Object, GraphQL::Execution::Lazy]
         # @raise [GraphQL::UnauthorizedError] if the user-provided hook returns `false`
         def authorized_new(object, context)
-          trace_payload = { context: context, type: self, object: object, path: context[:current_path] }
-
-          maybe_lazy_auth_val = context.query.trace("authorized", trace_payload) do
+          maybe_lazy_auth_val = context.query.current_trace.authorized(query: context.query, type: self, object: object) do
             begin
               authorized?(object, context)
             rescue GraphQL::UnauthorizedError => err
@@ -62,7 +69,7 @@ module GraphQL
 
           auth_val = if context.schema.lazy?(maybe_lazy_auth_val)
             GraphQL::Execution::Lazy.new do
-              context.query.trace("authorized_lazy", trace_payload) do
+              context.query.current_trace.authorized_lazy(query: context.query, type: self, object: object) do
                 context.schema.sync_lazy(maybe_lazy_auth_val)
               end
             end
@@ -70,7 +77,7 @@ module GraphQL
             maybe_lazy_auth_val
           end
 
-          context.schema.after_lazy(auth_val) do |is_authorized|
+          context.query.after_lazy(auth_val) do |is_authorized|
             if is_authorized
               self.new(object, context)
             else
@@ -88,6 +95,10 @@ module GraphQL
             end
           end
         end
+
+        def scoped_new(object, context)
+          self.new(object, context)
+        end
       end
 
       def initialize(object, context)

data/lib/graphql/schema/printer.rb

@@ -36,15 +36,11 @@ module GraphQL
 
       # @param schema [GraphQL::Schema]
       # @param context [Hash]
-      # @param only [<#call(member, ctx)>]
-      # @param except [<#call(member, ctx)>]
       # @param introspection [Boolean] Should include the introspection types in the string?
-      def initialize(schema, context: nil, only: nil, except: nil, introspection: false)
+      def initialize(schema, context: nil, introspection: false)
         @document_from_schema = GraphQL::Language::DocumentFromSchemaDefinition.new(
           schema,
           context: context,
-          only: only,
-          except: except,
           include_introspection_types: introspection,
         )
 
@@ -57,12 +53,19 @@ module GraphQL
         query_root = Class.new(GraphQL::Schema::Object) do
           graphql_name "Root"
           field :throwaway_field, String
+          def self.visible?(ctx)
+            false
+          end
         end
-        schema = Class.new(GraphQL::Schema) { query(query_root) }
+        schema = Class.new(GraphQL::Schema) {
+          query(query_root)
+          def self.visible?(member, _ctx)
+            member.graphql_name != "Root"
+          end
+        }
 
         introspection_schema_ast = GraphQL::Language::DocumentFromSchemaDefinition.new(
           schema,
-          except: ->(member, _) { member.graphql_name == "Root" },
           include_introspection_types: true,
           include_built_in_directives: true,
         ).document
@@ -92,7 +95,7 @@ module GraphQL
 
       class IntrospectionPrinter < GraphQL::Language::Printer
         def print_schema_definition(schema)
-          "schema {\n  query: Root\n}"
+          print_string("schema {\n  query: Root\n}")
         end
       end
     end