graphql 1.9.17 → 1.11.7

data/lib/graphql/schema/field.rb

@@ -13,8 +13,10 @@ module GraphQL
       include GraphQL::Schema::Member::CachedGraphQLDefinition
       include GraphQL::Schema::Member::AcceptsDefinition
       include GraphQL::Schema::Member::HasArguments
+      include GraphQL::Schema::Member::HasAstNode
       include GraphQL::Schema::Member::HasPath
       extend GraphQL::Schema::FindInheritedValue
+      include GraphQL::Schema::FindInheritedValue::EmptyObjects
 
       # @return [String] the GraphQL name for this field, camelized unless `camelize: false` is provided
       attr_reader :name
@@ -34,10 +36,19 @@ module GraphQL
       # @return [Symbol] The method on the type to look up
       attr_reader :resolver_method
 
-      # @return [Class] The type that this field belongs to
-      attr_reader :owner
+      # @return [Class] The thing this field was defined on (type, mutation, resolver)
+      attr_accessor :owner
 
-      # @return [Symobol] the original name of the field, passed in by the user
+      # @return [Class] The GraphQL type this field belongs to. (For fields defined on mutations, it's the payload type)
+      def owner_type
+        @owner_type ||= if owner < GraphQL::Schema::Mutation
+          owner.payload_type
+        else
+          owner
+        end
+      end
+
+      # @return [Symbol] the original name of the field, passed in by the user
       attr_reader :original_name
 
       # @return [Class, nil] The {Schema::Resolver} this field was derived from, if there is one
@@ -45,13 +56,18 @@ module GraphQL
         @resolver_class
       end
 
+      # @return [Boolean] Is this field a predefined introspection field?
+      def introspection?
+        @introspection
+      end
+
       alias :mutation :resolver
 
       # @return [Boolean] Apply tracing to this field? (Default: skip scalars, this is the override value)
       attr_reader :trace
 
       # @return [String, nil]
-      attr_reader :subscription_scope
+      attr_accessor :subscription_scope
 
       # Create a field instance from a list of arguments, keyword arguments, and a block.
       #
@@ -152,6 +168,14 @@ module GraphQL
         end
       end
 
+      # @return Boolean
+      attr_reader :relay_node_field
+
+      # @return [Boolean] Should we warn if this field's name conflicts with a built-in method?
+      def method_conflict_warning?
+        @method_conflict_warning
+      end
+
       # @param name [Symbol] The underscore-cased version of this field name (will be camelized for the GraphQL API)
       # @param type [Class, GraphQL::BaseType, Array] The return type of this field
       # @param owner [Class] The type that this field belongs to
@@ -162,7 +186,8 @@ module GraphQL
       # @param hash_key [String, Symbol] The hash key to lookup on the underlying object (if its a Hash) to resolve this field (defaults to `name` or `name.to_s`)
       # @param resolver_method [Symbol] The method on the type to call to resolve this field (defaults to `name`)
       # @param connection [Boolean] `true` if this field should get automagic connection behavior; default is to infer by `*Connection` in the return type name
-      # @param max_page_size [Integer] For connections, the maximum number of items to return from this field
+      # @param connection_extension [Class] The extension to add, to implement connections. If `nil`, no extension is added.
+      # @param max_page_size [Integer, nil] For connections, the maximum number of items to return from this field, or `nil` to allow unlimited results.
       # @param introspection [Boolean] If true, this field will be marked as `#introspection?` and the name may begin with `__`
       # @param resolve [<#call(obj, args, ctx)>] **deprecated** for compatibility with <1.8.0
       # @param field [GraphQL::Field, GraphQL::Schema::Field] **deprecated** for compatibility with <1.8.0
@@ -175,7 +200,10 @@ module GraphQL
       # @param subscription_scope [Symbol, String] A key in `context` which will be used to scope subscription payloads
       # @param extensions [Array<Class, Hash<Class => Object>>] Named extensions to apply to this field (see also {#extension})
       # @param trace [Boolean] If true, a {GraphQL::Tracing} tracer will measure this scalar field
-      def initialize(type: nil, name: nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, resolver_method: nil, resolve: nil, connection: nil, max_page_size: nil, scope: nil, introspection: false, camelize: true, trace: nil, complexity: 1, extras: [], extensions: [], resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, arguments: {}, &definition_block)
+      # @param broadcastable [Boolean] Whether or not this field can be distributed in subscription broadcasts
+      # @param ast_node [Language::Nodes::FieldDefinition, nil] If this schema was parsed from definition, this AST node defined the field
+      # @param method_conflict_warning [Boolean] If false, skip the warning if this field's method conflicts with a built-in method
+      def initialize(type: nil, name: nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, resolver_method: nil, resolve: nil, connection: nil, max_page_size: :not_given, scope: nil, introspection: false, camelize: true, trace: nil, complexity: 1, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: nil, arguments: EMPTY_HASH, &definition_block)
         if name.nil?
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
         end
@@ -191,8 +219,9 @@ module GraphQL
           raise ArgumentError, "keyword `extras:` may only be used with method-based resolve and class-based field such as mutation class, please remove `field:`, `function:` or `resolve:`"
         end
         @original_name = name
-        @underscored_name = -Member::BuildType.underscore(name.to_s)
-        @name = -(camelize ? Member::BuildType.camelize(name.to_s) : name.to_s)
+        name_s = -name.to_s
+        @underscored_name = -Member::BuildType.underscore(name_s)
+        @name = -(camelize ? Member::BuildType.camelize(name_s) : name_s)
         @description = description
         if field.is_a?(GraphQL::Schema::Field)
           raise ArgumentError, "Instead of passing a field as `field:`, use `add_field(field)` to add an already-defined field."
@@ -218,32 +247,34 @@ module GraphQL
         end
 
         # TODO: I think non-string/symbol hash keys are wrongly normalized (eg `1` will not work)
-        method_name = method || hash_key || @underscored_name
-        resolver_method ||= @underscored_name.to_sym
+        method_name = method || hash_key || name_s
+        resolver_method ||= name_s.to_sym
 
-        @method_str = method_name.to_s
+        @method_str = -method_name.to_s
         @method_sym = method_name.to_sym
         @resolver_method = resolver_method
         @complexity = complexity
         @return_type_expr = type
         @return_type_null = null
         @connection = connection
-        @max_page_size = max_page_size
+        @has_max_page_size = max_page_size != :not_given
+        @max_page_size = max_page_size == :not_given ? nil : max_page_size
         @introspection = introspection
         @extras = extras
+        @broadcastable = broadcastable
         @resolver_class = resolver_class
         @scope = scope
         @trace = trace
         @relay_node_field = relay_node_field
         @relay_nodes_field = relay_nodes_field
+        @ast_node = ast_node
+        @method_conflict_warning = method_conflict_warning
 
-        # Override the default from HasArguments
-        @own_arguments = {}
         arguments.each do |name, arg|
           if arg.is_a?(Hash)
             argument(name: name, **arg)
           else
-            @own_arguments[name] = arg
+            add_argument(arg)
           end
         end
 
@@ -251,7 +282,7 @@ module GraphQL
         @subscription_scope = subscription_scope
 
         # Do this last so we have as much context as possible when initializing them:
-        @extensions = []
+        @extensions = EMPTY_ARRAY
         if extensions.any?
           self.extensions(extensions)
         end
@@ -262,8 +293,8 @@ module GraphQL
         end
         # The problem with putting this after the definition_block
         # is that it would override arguments
-        if connection?
-          self.extension(self.class.connection_extension)
+        if connection? && connection_extension
+          self.extension(connection_extension)
         end
 
         if definition_block
@@ -275,6 +306,13 @@ module GraphQL
         end
       end
 
+      # If true, subscription updates with this field can be shared between viewers
+      # @return [Boolean, nil]
+      # @see GraphQL::Subscriptions::BroadcastAnalyzer
+      def broadcastable?
+        @broadcastable
+      end
+
       # @param text [String]
       # @return [String]
       def description(text = nil)
@@ -305,6 +343,9 @@ module GraphQL
           # Read the value
           @extensions
         else
+          if @extensions.frozen?
+            @extensions = @extensions.dup
+          end
           new_extensions.each do |extension|
             if extension.is_a?(Hash)
               extension = extension.to_a[0]
@@ -342,12 +383,15 @@ module GraphQL
           # Read the value
           @extras
         else
+          if @extras.frozen?
+            @extras = @extras.dup
+          end
           # Append to the set of extras on this field
           @extras.concat(new_extras)
         end
       end
 
-      def complexity(new_complexity)
+      def complexity(new_complexity = nil)
         case new_complexity
         when Proc
           if new_complexity.parameters.size != 3
@@ -360,12 +404,19 @@ module GraphQL
           end
         when Numeric
           @complexity = new_complexity
+        when nil
+          @complexity
         else
           raise("Invalid complexity: #{new_complexity.inspect} on #{@name}")
         end
       end
 
-      # @return [Integer, nil] Applied to connections if present
+      # @return [Boolean] True if this field's {#max_page_size} should override the schema default.
+      def has_max_page_size?
+        @has_max_page_size
+      end
+
+      # @return [Integer, nil] Applied to connections if {#has_max_page_size?}
       attr_reader :max_page_size
 
       # @return [GraphQL::Field]
@@ -416,6 +467,7 @@ module GraphQL
         field_defn.introspection = @introspection
         field_defn.complexity = @complexity
         field_defn.subscription_scope = @subscription_scope
+        field_defn.ast_node = ast_node
 
         arguments.each do |name, defn|
           arg_graphql = defn.to_graphql
@@ -433,14 +485,25 @@ module GraphQL
 
         # Ok, `self` isn't a class, but this is for consistency with the classes
         field_defn.metadata[:type_class] = self
-
+        field_defn.arguments_class = GraphQL::Query::Arguments.construct_arguments_class(field_defn)
         field_defn
       end
 
+      attr_writer :type
+
       def type
-        @type ||= Member::BuildType.parse_type(@return_type_expr, null: @return_type_null)
-      rescue
-        raise ArgumentError, "Failed to build return type for #{@owner.graphql_name}.#{name} from #{@return_type_expr.inspect}: #{$!.message}", $!.backtrace
+        @type ||= if @function
+          Member::BuildType.parse_type(@function.type, null: false)
+        elsif @field
+          Member::BuildType.parse_type(@field.type, null: false)
+        else
+          Member::BuildType.parse_type(@return_type_expr, null: @return_type_null)
+        end
+      rescue GraphQL::Schema::InvalidDocumentError => err
+        # Let this propagate up
+        raise err
+      rescue StandardError => err
+        raise ArgumentError, "Failed to build return type for #{@owner.graphql_name}.#{name} from #{@return_type_expr.inspect}: (#{err.class}) #{err.message}", err.backtrace
       end
 
       def visible?(context)
@@ -459,14 +522,14 @@ module GraphQL
         end
       end
 
-      def authorized?(object, context)
+      def authorized?(object, args, context)
         if @resolver_class
           # The resolver will check itself during `resolve()`
           @resolver_class.authorized?(object, context)
         else
           # Faster than `.any?`
           arguments.each_value do |arg|
-            if !arg.authorized?(object, context)
+            if args.key?(arg.keyword) && !arg.authorized?(object, args[arg.keyword], context)
               return false
             end
           end
@@ -485,21 +548,22 @@ module GraphQL
           # Some legacy fields can have `nil` here, not exactly sure why.
           # @see https://github.com/rmosolgo/graphql-ruby/issues/1990 before removing
           inner_obj = after_obj && after_obj.object
-          if authorized?(inner_obj, query_ctx)
-            ruby_args = to_ruby_args(after_obj, args, ctx)
-            # Then if it passed, resolve the field
-            if @resolve_proc
-              # Might be nil, still want to call the func in that case
-              with_extensions(inner_obj, ruby_args, query_ctx) do |extended_obj, extended_args|
-                # Pass the GraphQL args here for compatibility:
-                @resolve_proc.call(extended_obj, args, ctx)
+          ctx.schema.after_lazy(to_ruby_args(after_obj, args, ctx)) do |ruby_args|
+            if authorized?(inner_obj, ruby_args, query_ctx)
+              # Then if it passed, resolve the field
+              if @resolve_proc
+                # Might be nil, still want to call the func in that case
+                with_extensions(inner_obj, ruby_args, query_ctx) do |extended_obj, extended_args|
+                  # Pass the GraphQL args here for compatibility:
+                  @resolve_proc.call(extended_obj, args, ctx)
+                end
+              else
+                public_send_field(after_obj, ruby_args, query_ctx)
               end
             else
-              public_send_field(after_obj, ruby_args, ctx)
+              err = GraphQL::UnauthorizedFieldError.new(object: inner_obj, type: obj.class, context: ctx, field: self)
+              query_ctx.schema.unauthorized_field(err)
             end
-          else
-            err = GraphQL::UnauthorizedFieldError.new(object: inner_obj, type: obj.class, context: ctx, field: self)
-            query_ctx.schema.unauthorized_field(err)
           end
         end
       end
@@ -516,34 +580,13 @@ module GraphQL
         begin
           # Unwrap the GraphQL object to get the application object.
           application_object = object.object
-          if self.authorized?(application_object, ctx)
-            # Apply field extensions
-            with_extensions(object, args, ctx) do |extended_obj, extended_args|
-              field_receiver = if @resolver_class
-                resolver_obj = if extended_obj.is_a?(GraphQL::Schema::Object)
-                  extended_obj.object
-                else
-                  extended_obj
-                end
-                @resolver_class.new(object: resolver_obj, context: ctx, field: self)
-              else
-                extended_obj
-              end
-
-              if field_receiver.respond_to?(@resolver_method)
-                # Call the method with kwargs, if there are any
-                if extended_args.any?
-                  field_receiver.public_send(@resolver_method, **extended_args)
-                else
-                  field_receiver.public_send(@resolver_method)
-                end
-              else
-                resolve_field_method(field_receiver, extended_args, ctx)
-              end
+          ctx.schema.after_lazy(self.authorized?(application_object, args, ctx)) do |is_authorized|
+            if is_authorized
+              public_send_field(object, args, ctx)
+            else
+              err = GraphQL::UnauthorizedFieldError.new(object: application_object, type: object.class, context: ctx, field: self)
+              ctx.schema.unauthorized_field(err)
             end
-          else
-            err = GraphQL::UnauthorizedFieldError.new(object: application_object, type: object.class, context: ctx, field: self)
-            ctx.schema.unauthorized_field(err)
           end
         rescue GraphQL::UnauthorizedFieldError => err
           err.field ||= self
@@ -555,46 +598,9 @@ module GraphQL
         err
       end
 
-      # Find a way to resolve this field, checking:
-      #
-      # - Hash keys, if the wrapped object is a hash;
-      # - A method on the wrapped object;
-      # - Or, raise not implemented.
-      #
-      # This can be overridden by defining a method on the object type.
-      # @param obj [GraphQL::Schema::Object]
-      # @param ruby_kwargs [Hash<Symbol => Object>]
-      # @param ctx [GraphQL::Query::Context]
-      def resolve_field_method(obj, ruby_kwargs, ctx)
-        if obj.object.is_a?(Hash)
-          inner_object = obj.object
-          if inner_object.key?(@method_sym)
-            inner_object[@method_sym]
-          else
-            inner_object[@method_str]
-          end
-        elsif obj.object.respond_to?(@method_sym)
-          if ruby_kwargs.any?
-            obj.object.public_send(@method_sym, **ruby_kwargs)
-          else
-            obj.object.public_send(@method_sym)
-          end
-        else
-          raise <<-ERR
-        Failed to implement #{@owner.graphql_name}.#{@name}, tried:
-
-        - `#{obj.class}##{@resolver_method}`, which did not exist
-        - `#{obj.object.class}##{@method_sym}`, which did not exist
-        - Looking up hash key `#{@method_sym.inspect}` or `#{@method_str.inspect}` on `#{obj.object}`, but it wasn't a Hash
-
-        To implement this field, define one of the methods above (and check for typos)
-        ERR
-        end
-      end
-
       # @param ctx [GraphQL::Query::Context::FieldResolutionContext]
       def fetch_extra(extra_name, ctx)
-        if extra_name != :path && respond_to?(extra_name)
+        if extra_name != :path && extra_name != :ast_node && respond_to?(extra_name)
           self.public_send(extra_name)
         elsif ctx.respond_to?(extra_name)
           ctx.public_send(extra_name)
@@ -617,11 +623,36 @@ module GraphQL
         if graphql_args.any? || @extras.any?
           # Splat the GraphQL::Arguments to Ruby keyword arguments
           ruby_kwargs = graphql_args.to_kwargs
+          maybe_lazies = []
           # Apply any `prepare` methods. Not great code organization, can this go somewhere better?
           arguments.each do |name, arg_defn|
             ruby_kwargs_key = arg_defn.keyword
-            if ruby_kwargs.key?(ruby_kwargs_key) && arg_defn.prepare
-              ruby_kwargs[ruby_kwargs_key] = arg_defn.prepare_value(obj, ruby_kwargs[ruby_kwargs_key])
+
+            if ruby_kwargs.key?(ruby_kwargs_key)
+              loads = arg_defn.loads
+              value = ruby_kwargs[ruby_kwargs_key]
+              loaded_value = if loads && !arg_defn.from_resolver?
+                if arg_defn.type.list?
+                  loaded_values = value.map { |val| load_application_object(arg_defn, loads, val, field_ctx.query.context) }
+                  field_ctx.schema.after_any_lazies(loaded_values) { |result| result }
+                else
+                  load_application_object(arg_defn, loads, value, field_ctx.query.context)
+                end
+              elsif arg_defn.type.list? && value.is_a?(Array)
+                field_ctx.schema.after_any_lazies(value, &:itself)
+              else
+                value
+              end
+
+              maybe_lazies << field_ctx.schema.after_lazy(loaded_value) do |loaded_value|
+                prepared_value = if arg_defn.prepare
+                  arg_defn.prepare_value(obj, loaded_value)
+                else
+                  loaded_value
+                end
+
+                ruby_kwargs[ruby_kwargs_key] = prepared_value
+              end
             end
           end
 
@@ -629,30 +660,60 @@ module GraphQL
             ruby_kwargs[extra_arg] = fetch_extra(extra_arg, field_ctx)
           end
 
-          ruby_kwargs
+          field_ctx.schema.after_any_lazies(maybe_lazies) do
+            ruby_kwargs
+          end
         else
           NO_ARGS
         end
       end
 
-      def public_send_field(obj, ruby_kwargs, field_ctx)
-        query_ctx = field_ctx.query.context
-        with_extensions(obj, ruby_kwargs, query_ctx) do |extended_obj, extended_args|
+      def public_send_field(unextended_obj, unextended_ruby_kwargs, query_ctx)
+        with_extensions(unextended_obj, unextended_ruby_kwargs, query_ctx) do |obj, ruby_kwargs|
           if @resolver_class
-            if extended_obj.is_a?(GraphQL::Schema::Object)
-              extended_obj = extended_obj.object
+            if obj.is_a?(GraphQL::Schema::Object)
+              obj = obj.object
             end
-            extended_obj = @resolver_class.new(object: extended_obj, context: query_ctx, field: self)
+            obj = @resolver_class.new(object: obj, context: query_ctx, field: self)
           end
 
-          if extended_obj.respond_to?(@resolver_method)
-            if extended_args.any?
-              extended_obj.public_send(@resolver_method, **extended_args)
+          # Find a way to resolve this field, checking:
+          #
+          # - A method on the type instance;
+          # - Hash keys, if the wrapped object is a hash;
+          # - A method on the wrapped object;
+          # - Or, raise not implemented.
+          #
+          if obj.respond_to?(@resolver_method)
+            # Call the method with kwargs, if there are any
+            if ruby_kwargs.any?
+              obj.public_send(@resolver_method, **ruby_kwargs)
+            else
+              obj.public_send(@resolver_method)
+            end
+          elsif obj.object.is_a?(Hash)
+            inner_object = obj.object
+            if inner_object.key?(@method_sym)
+              inner_object[@method_sym]
+            else
+              inner_object[@method_str]
+            end
+          elsif obj.object.respond_to?(@method_sym)
+            if ruby_kwargs.any?
+              obj.object.public_send(@method_sym, **ruby_kwargs)
             else
-              extended_obj.public_send(@resolver_method)
+              obj.object.public_send(@method_sym)
             end
           else
-            resolve_field_method(extended_obj, extended_args, query_ctx)
+            raise <<-ERR
+          Failed to implement #{@owner.graphql_name}.#{@name}, tried:
+
+          - `#{obj.class}##{@resolver_method}`, which did not exist
+          - `#{obj.object.class}##{@method_sym}`, which did not exist
+          - Looking up hash key `#{@method_sym.inspect}` or `#{@method_str.inspect}` on `#{obj.object}`, but it wasn't a Hash
+
+          To implement this field, define one of the methods above (and check for typos)
+          ERR
           end
         end
       end
@@ -664,32 +725,42 @@ module GraphQL
         if @extensions.empty?
           yield(obj, args)
         else
-          # Save these so that the originals can be re-given to `after_resolve` handlers.
-          original_args = args
-          original_obj = obj
-
-          memos = []
-          value = run_extensions_before_resolve(memos, obj, args, ctx) do |extended_obj, extended_args|
-            yield(extended_obj, extended_args)
+          # This is a hack to get the _last_ value for extended obj and args,
+          # in case one of the extensions doesn't `yield`.
+          # (There's another implementation that uses multiple-return, but I'm wary of the perf cost of the extra arrays)
+          extended = { args: args, obj: obj, memos: nil }
+          value = run_extensions_before_resolve(obj, args, ctx, extended) do |obj, args|
+            yield(obj, args)
           end
 
+          extended_obj = extended[:obj]
+          extended_args = extended[:args]
+          memos = extended[:memos] || EMPTY_HASH
+
           ctx.schema.after_lazy(value) do |resolved_value|
-            @extensions.each_with_index do |ext, idx|
+            idx = 0
+            @extensions.each do |ext|
               memo = memos[idx]
               # TODO after_lazy?
-              resolved_value = ext.after_resolve(object: original_obj, arguments: original_args, context: ctx, value: resolved_value, memo: memo)
+              resolved_value = ext.after_resolve(object: extended_obj, arguments: extended_args, context: ctx, value: resolved_value, memo: memo)
+              idx += 1
             end
             resolved_value
           end
         end
       end
 
-      def run_extensions_before_resolve(memos, obj, args, ctx, idx: 0)
+      def run_extensions_before_resolve(obj, args, ctx, extended, idx: 0)
         extension = @extensions[idx]
         if extension
           extension.resolve(object: obj, arguments: args, context: ctx) do |extended_obj, extended_args, memo|
-            memos << memo
-            run_extensions_before_resolve(memos, extended_obj, extended_args, ctx, idx: idx + 1) { |o, a| yield(o, a) }
+            if memo
+              memos = extended[:memos] ||= {}
+              memos[idx] = memo
+            end
+            extended[:obj] = extended_obj
+            extended[:args] = extended_args
+            run_extensions_before_resolve(extended_obj, extended_args, ctx, extended, idx: idx + 1) { |o, a| yield(o, a) }
           end
         else
           yield(obj, args)

data/lib/graphql/schema/find_inherited_value.rb

@@ -1,6 +1,19 @@
 module GraphQL
   class Schema
     module FindInheritedValue
+      module EmptyObjects
+        EMPTY_HASH = {}.freeze
+        EMPTY_ARRAY = [].freeze
+      end
+
+      def self.extended(child_cls)
+        child_cls.singleton_class.include(EmptyObjects)
+      end
+
+      def self.included(child_cls)
+        child_cls.include(EmptyObjects)
+      end
+
       private
 
       def find_inherited_value(method_name, default_value = nil)

data/lib/graphql/schema/finder.rb

@@ -38,7 +38,7 @@ module GraphQL
 
           find_in_directive(directive, path: path)
         else
-          type = schema.types[type_or_directive]
+          type = schema.get_type(type_or_directive)
 
           if type.nil?
             raise MemberNotFoundError, "Could not find type `#{type_or_directive}` in schema."
@@ -66,22 +66,24 @@ module GraphQL
       end
 
       def find_in_type(type, path:)
-        case type
-        when GraphQL::ObjectType
+        case type.kind.name
+        when "OBJECT"
           find_in_fields_type(type, kind: "object", path: path)
-        when GraphQL::InterfaceType
+        when "INTERFACE"
           find_in_fields_type(type, kind: "interface", path: path)
-        when GraphQL::InputObjectType
+        when "INPUT_OBJECT"
           find_in_input_object(type, path: path)
-        when GraphQL::UnionType
+        when "UNION"
           # Error out if path that was provided is too long
           # i.e UnionType.PossibleType.aField
           # Use PossibleType.aField instead.
           if invalid = path.first
             raise MemberNotFoundError, "Cannot select union possible type `#{invalid}`. Select the type directly instead."
           end
-        when GraphQL::EnumType
+        when "ENUM"
           find_in_enum_type(type, path: path)
+        else
+          raise "Unexpected find_in_type: #{type.inspect} (#{path})"
         end
       end
 
@@ -90,7 +92,7 @@ module GraphQL
         field = schema.get_field(type, field_name)
 
         if field.nil?
-          raise MemberNotFoundError, "Could not find field `#{field_name}` on #{kind} type `#{type}`."
+          raise MemberNotFoundError, "Could not find field `#{field_name}` on #{kind} type `#{type.graphql_name}`."
         end
 
         return field if path.empty?
@@ -117,10 +119,10 @@ module GraphQL
 
       def find_in_input_object(input_object, path:)
         field_name = path.shift
-        input_field = input_object.input_fields[field_name]
+        input_field = input_object.arguments[field_name]
 
         if input_field.nil?
-          raise MemberNotFoundError, "Could not find input field `#{field_name}` on input object type `#{input_object}`."
+          raise MemberNotFoundError, "Could not find input field `#{field_name}` on input object type `#{input_object.graphql_name}`."
         end
 
         # Error out if path that was provided is too long
@@ -137,7 +139,7 @@ module GraphQL
         enum_value = enum_type.values[value_name]
 
         if enum_value.nil?
-          raise MemberNotFoundError, "Could not find enum value `#{value_name}` on enum type `#{enum_type}`."
+          raise MemberNotFoundError, "Could not find enum value `#{value_name}` on enum type `#{enum_type.graphql_name}`."
         end
 
         # Error out if path that was provided is too long