graphql 1.10.14 → 1.11.4

data/lib/graphql/invalid_null_error.rb

@@ -28,5 +28,23 @@ module GraphQL
     def parent_error?
       false
     end
+
+    class << self
+      attr_accessor :parent_class
+
+      def subclass_for(parent_class)
+        subclass = Class.new(self)
+        subclass.parent_class = parent_class
+        subclass
+      end
+
+      def inspect
+        if name.nil? && parent_class.respond_to?(:mutation) && (mutation = parent_class.mutation)
+          "#{mutation.inspect}::#{parent_class.graphql_name}::InvalidNullError"
+        else
+          super
+        end
+      end
+    end
   end
 end

data/lib/graphql/language/nodes.rb

@@ -524,6 +524,7 @@ module GraphQL
 
       # Usage of a variable in a query. Name does _not_ include `$`.
       class VariableIdentifier < NameOnlyNode
+        self.children_method_name = :value
       end
 
       class SchemaDefinition < AbstractNode

data/lib/graphql/language/visitor.rb

@@ -89,7 +89,7 @@ module GraphQL
       # @param parent [GraphQL::Language::Nodes::AbstractNode, nil] the previously-visited node, or `nil` if this is the root node.
       # @return [Array, nil] If there were modifications, it returns an array of new nodes, otherwise, it returns `nil`.
       def on_abstract_node(node, parent)
-        if node == DELETE_NODE
+        if node.equal?(DELETE_NODE)
           # This might be passed to `super(DELETE_NODE, ...)`
           # by a user hook, don't want to keep visiting in that case.
           nil
@@ -179,7 +179,7 @@ module GraphQL
             # The user-provided hook returned a new node.
             new_parent = new_parent && new_parent.replace_child(node, new_node)
             return new_node, new_parent
-          elsif new_node == DELETE_NODE
+          elsif new_node.equal?(DELETE_NODE)
             # The user-provided hook requested to remove this node
             new_parent = new_parent && new_parent.delete_child(node)
             return nil, new_parent

data/lib/graphql/pagination/connection.rb

@@ -15,17 +15,15 @@ module GraphQL
       class PaginationImplementationMissingError < GraphQL::Error
       end
 
-      # @return [Class] The class to use for wrapping items as `edges { ... }`. Defaults to `Connection::Edge`
-      def self.edge_class
-        self::Edge
-      end
-
       # @return [Object] A list object, from the application. This is the unpaginated value passed into the connection.
       attr_reader :items
 
       # @return [GraphQL::Query::Context]
       attr_accessor :context
 
+      # @return [Object] the object this collection belongs to
+      attr_accessor :parent
+
       # Raw access to client-provided values. (`max_page_size` not applied to first or last.)
       attr_accessor :before_value, :after_value, :first_value, :last_value
 
@@ -49,19 +47,21 @@ module GraphQL
 
       # @param items [Object] some unpaginated collection item, like an `Array` or `ActiveRecord::Relation`
       # @param context [Query::Context]
+      # @param parent [Object] The object this collection belongs to
       # @param first [Integer, nil] The limit parameter from the client, if it provided one
       # @param after [String, nil] A cursor for pagination, if the client provided one
       # @param last [Integer, nil] Limit parameter from the client, if provided
       # @param before [String, nil] A cursor for pagination, if the client provided one.
       # @param max_page_size [Integer, nil] A configured value to cap the result size. Applied as `first` if neither first or last are given.
-      def initialize(items, context: nil, first: nil, after: nil, max_page_size: :not_given, last: nil, before: nil)
+      def initialize(items, parent: nil, context: nil, first: nil, after: nil, max_page_size: :not_given, last: nil, before: nil, edge_class: nil)
         @items = items
+        @parent = parent
         @context = context
         @first_value = first
         @after_value = after
         @last_value = last
         @before_value = before
-
+        @edge_class = edge_class || self.class::Edge
         # This is only true if the object was _initialized_ with an override
         # or if one is assigned later.
         @has_max_page_size_override = max_page_size != :not_given
@@ -112,9 +112,12 @@ module GraphQL
 
       # @return [Array<Edge>] {nodes}, but wrapped with Edge instances
       def edges
-        @edges ||= nodes.map { |n| self.class.edge_class.new(n, self) }
+        @edges ||= nodes.map { |n| @edge_class.new(n, self) }
       end
 
+      # @return [Class] A wrapper class for edges of this connection
+      attr_accessor :edge_class
+
       # @return [Array<Object>] A slice of {items}, constrained by {@first_value}/{@after_value}/{@last_value}/{@before_value}
       def nodes
         raise PaginationImplementationMissingError, "Implement #{self.class}#nodes to paginate `@items`"
@@ -185,17 +188,19 @@ module GraphQL
       # A wrapper around paginated items. It includes a {cursor} for pagination
       # and could be extended with custom relationship-level data.
       class Edge
-        def initialize(item, connection)
+        attr_reader :node
+
+        def initialize(node, connection)
           @connection = connection
-          @item = item
+          @node = node
         end
 
-        def node
-          @item
+        def parent
+          @connection.parent
         end
 
         def cursor
-          @connection.cursor_for(@item)
+          @cursor ||= @connection.cursor_for(@node)
         end
       end
     end

data/lib/graphql/pagination/connections.rb

@@ -65,29 +65,42 @@ module GraphQL
 
       # Used by the runtime to wrap values in connection wrappers.
       # @api Private
-      def wrap(field, object, arguments, context, wrappers: all_wrappers)
+      def wrap(field, parent, items, arguments, context, wrappers: all_wrappers)
         impl = nil
 
-        object.class.ancestors.each { |cls|
+        items.class.ancestors.each { |cls|
           impl = wrappers[cls]
           break if impl
         }
 
         if impl.nil?
-          raise ImplementationMissingError, "Couldn't find a connection wrapper for #{object.class} during #{field.path} (#{object.inspect})"
+          raise ImplementationMissingError, "Couldn't find a connection wrapper for #{items.class} during #{field.path} (#{items.inspect})"
         end
 
         impl.new(
-          object,
+          items,
           context: context,
+          parent: parent,
           max_page_size: field.max_page_size || context.schema.default_max_page_size,
           first: arguments[:first],
           after: arguments[:after],
           last: arguments[:last],
           before: arguments[:before],
+          edge_class: edge_class_for_field(field),
         )
       end
 
+      # use an override if there is one
+      # @api private
+      def edge_class_for_field(field)
+        conn_type = field.type.unwrap
+        conn_type_edge_type = conn_type.respond_to?(:edge_class) && conn_type.edge_class
+        if conn_type_edge_type && conn_type_edge_type != Relay::Edge
+          conn_type_edge_type
+        else
+          nil
+        end
+      end
       protected
 
       attr_reader :wrappers

data/lib/graphql/query.rb

@@ -96,8 +96,7 @@ module GraphQL
       @fragments = nil
       @operations = nil
       @validate = validate
-      # TODO: remove support for global tracers
-      @tracers = schema.tracers + GraphQL::Tracing.tracers + (context ? context.fetch(:tracers, []) : [])
+      @tracers = schema.tracers + (context ? context.fetch(:tracers, []) : [])
       # Support `ctx[:backtrace] = true` for wrapping backtraces
       if context && context[:backtrace] && !@tracers.include?(GraphQL::Backtrace::Tracer)
         @tracers << GraphQL::Backtrace::Tracer

data/lib/graphql/query/context.rb

@@ -168,7 +168,6 @@ module GraphQL
       attr_accessor :scoped_context
 
       def_delegators :@provided_values, :[]=
-      def_delegators :to_h, :fetch, :dig
       def_delegators :@query, :trace, :interpreter?
 
       # @!method []=(key, value)
@@ -180,6 +179,26 @@ module GraphQL
         @provided_values[key]
       end
 
+      UNSPECIFIED_FETCH_DEFAULT = Object.new
+
+      def fetch(key, default = UNSPECIFIED_FETCH_DEFAULT)
+        if @scoped_context.key?(key)
+          @scoped_context[key]
+        elsif @provided_values.key?(key)
+          @provided_values[key]
+        elsif default != UNSPECIFIED_FETCH_DEFAULT
+          default
+        elsif block_given?
+          yield(self, key)
+        else
+          raise KeyError.new(key: key)
+        end
+      end
+
+      def dig(key, *other_keys)
+        @scoped_context.key?(key) ? @scoped_context.dig(key, *other_keys) : @provided_values.dig(key, *other_keys)
+      end
+
       def to_h
         @provided_values.merge(@scoped_context)
       end

data/lib/graphql/query/fingerprint.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'digest/sha2'
+
 module GraphQL
   class Query
     # @api private

data/lib/graphql/query/validation_pipeline.rb

@@ -90,6 +90,9 @@ module GraphQL
         end
 
         @valid = @validation_errors.empty?
+      rescue SystemStackError => err
+        @valid = false
+        @schema.query_stack_error(@query, err)
       end
 
       # If there are max_* values, add them,

data/lib/graphql/schema.rb

@@ -127,7 +127,7 @@ module GraphQL
         end
       end
 
-      # @return [Symbol, nil] The method name to lazily resolve `obj`, or nil if `obj`'s class wasn't registered wtih {#lazy_resolve}.
+      # @return [Symbol, nil] The method name to lazily resolve `obj`, or nil if `obj`'s class wasn't registered with {#lazy_resolve}.
       def lazy_method_name(obj)
         lazy_methods.get(obj)
       end
@@ -1075,6 +1075,7 @@ module GraphQL
             raise GraphQL::Error, "Second definition of `subscription(...)` (#{new_subscription_object.inspect}) is invalid, already configured with #{@subscription_object.inspect}"
           else
             @subscription_object = new_subscription_object
+            add_subscription_extension_if_necessary
             add_type_and_traverse(new_subscription_object, root: true)
             nil
           end
@@ -1533,9 +1534,9 @@ module GraphQL
 
       # Add several directives at once
       # @param new_directives [Class]
-      def directives(new_directives = nil)
-        if new_directives
-          new_directives.each { |d| directive(d) }
+      def directives(*new_directives)
+        if new_directives.any?
+          new_directives.flatten.each { |d| directive(d) }
         end
 
         find_inherited_value(:directives, default_directives).merge(own_directives)
@@ -1549,11 +1550,11 @@ module GraphQL
       end
 
       def default_directives
-        {
+        @default_directives ||= {
           "include" => GraphQL::Schema::Directive::Include,
           "skip" => GraphQL::Schema::Directive::Skip,
           "deprecated" => GraphQL::Schema::Directive::Deprecated,
-        }
+        }.freeze
       end
 
       def tracer(new_tracer)
@@ -1648,6 +1649,24 @@ module GraphQL
         end
       end
 
+      # @api private
+      def add_subscription_extension_if_necessary
+        if interpreter? && !defined?(@subscription_extension_added) && subscription && self.subscriptions
+          @subscription_extension_added = true
+          if subscription.singleton_class.ancestors.include?(Subscriptions::SubscriptionRoot)
+            warn("`extend Subscriptions::SubscriptionRoot` is no longer required; you may remove it from #{self}'s `subscription` root type (#{subscription}).")
+          else
+            subscription.fields.each do |name, field|
+              field.extension(Subscriptions::DefaultSubscriptionResolveExtension)
+            end
+          end
+        end
+      end
+
+      def query_stack_error(query, err)
+        query.analysis_errors.push(GraphQL::AnalysisError.new("This query is too large to execute."))
+      end
+
       private
 
       def lazy_methods
@@ -1768,16 +1787,7 @@ module GraphQL
           if owner.kind.union?
             # It's a union with possible_types
             # Replace the item by class name
-            owner.type_memberships.each { |tm|
-              possible_type = tm.object_type
-              if possible_type.is_a?(String) && (possible_type == type.name)
-                # This is a match of Ruby class names, not graphql names,
-                # since strings are used to refer to constants.
-                tm.object_type = type
-              elsif possible_type.is_a?(LateBoundType) && possible_type.graphql_name == type.graphql_name
-                tm.object_type = type
-              end
-            }
+            owner.assign_type_membership_object_type(type)
             own_possible_types[owner.graphql_name] = owner.possible_types
           elsif type.kind.interface? && owner.kind.object?
             new_interfaces = []

data/lib/graphql/schema/build_from_definition.rb

@@ -43,9 +43,7 @@ module GraphQL
             when GraphQL::Language::Nodes::EnumTypeDefinition
               types[definition.name] = build_enum_type(definition, type_resolver)
             when GraphQL::Language::Nodes::ObjectTypeDefinition
-              is_subscription_root = (definition.name == "Subscription" && (schema_definition.nil? || schema_definition.subscription.nil?)) || (schema_definition && (definition.name == schema_definition.subscription))
-              should_extend_subscription_root = is_subscription_root && interpreter
-              types[definition.name] = build_object_type(definition, type_resolver, default_resolve: default_resolve, extend_subscription_root: should_extend_subscription_root)
+              types[definition.name] = build_object_type(definition, type_resolver, default_resolve: default_resolve)
             when GraphQL::Language::Nodes::InterfaceTypeDefinition
               types[definition.name] = build_interface_type(definition, type_resolver)
             when GraphQL::Language::Nodes::UnionTypeDefinition
@@ -204,7 +202,7 @@ module GraphQL
           end
         end
 
-        def build_object_type(object_type_definition, type_resolver, default_resolve:, extend_subscription_root:)
+        def build_object_type(object_type_definition, type_resolver, default_resolve:)
           builder = self
           type_def = nil
           typed_resolve_fn = ->(field, obj, args, ctx) { default_resolve.call(type_def, field, obj, args, ctx) }
@@ -214,10 +212,6 @@ module GraphQL
             graphql_name(object_type_definition.name)
             description(object_type_definition.description)
             ast_node(object_type_definition)
-            if extend_subscription_root
-              # This has to come before `field ...` configurations since it modifies them
-              extend Subscriptions::SubscriptionRoot
-            end
 
             object_type_definition.interfaces.each do |interface_name|
               interface_defn = type_resolver.call(interface_name)
@@ -303,7 +297,7 @@ module GraphQL
 
           field_definitions.map do |field_definition|
             type_name = resolve_type_name(field_definition.type)
-
+            resolve_method_name = "resolve_field_#{field_definition.name}"
             owner.field(
               field_definition.name,
               description: field_definition.description,
@@ -315,14 +309,15 @@ module GraphQL
               ast_node: field_definition,
               method_conflict_warning: false,
               camelize: false,
+              resolver_method: resolve_method_name,
             ) do
               builder.build_arguments(self, field_definition.arguments, type_resolver)
 
               # Don't do this for interfaces
               if default_resolve
-                # TODO fragile hack. formalize this API?
-                define_singleton_method :resolve_field_method do |obj, args, ctx|
-                  default_resolve.call(self, obj.object, args, ctx)
+                owner.send(:define_method, resolve_method_name) do |**args|
+                  field_instance = self.class.get_field(field_definition.name)
+                  default_resolve.call(field_instance, object, args, context)
                 end
               end
             end

data/lib/graphql/schema/build_from_definition/resolve_map.rb

@@ -45,8 +45,10 @@ module GraphQL
                 @resolve_hash[type_name_s][field_name.to_s] = resolve_fn
               end
             when Proc
-              # for example, __resolve_type
+              # for example, "resolve_type"
               @resolve_hash[type_name_s] = fields
+            else
+              raise ArgumentError, "Unexpected resolve hash value for #{type_name.inspect}: #{fields.inspect} (#{fields.class})"
             end
           end
 

data/lib/graphql/schema/enum_value.rb

@@ -41,6 +41,7 @@ module GraphQL
 
       def initialize(graphql_name, desc = nil, owner:, ast_node: nil, description: nil, value: nil, deprecation_reason: nil, &block)
         @graphql_name = graphql_name.to_s
+        GraphQL::NameValidator.validate!(@graphql_name)
         @description = desc || description
         @value = value.nil? ? @graphql_name : value
         @deprecation_reason = deprecation_reason

data/lib/graphql/schema/field.rb

@@ -36,9 +36,18 @@ 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
+      # @return [Class] The thing this field was defined on (type, mutation, resolver)
       attr_accessor :owner
 
+      # @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
 
@@ -191,9 +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
+      # @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: [], 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, arguments: EMPTY_HASH, &definition_block)
+      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: [], 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
@@ -237,8 +247,8 @@ 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_sym = method_name.to_sym
@@ -251,6 +261,7 @@ module GraphQL
         @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
@@ -295,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)
@@ -534,7 +552,7 @@ module GraphQL
                   @resolve_proc.call(extended_obj, args, ctx)
                 end
               else
-                public_send_field(after_obj, ruby_args, ctx)
+                public_send_field(after_obj, ruby_args, query_ctx)
               end
             else
               err = GraphQL::UnauthorizedFieldError.new(object: inner_obj, type: obj.class, context: ctx, field: self)
@@ -558,30 +576,7 @@ module GraphQL
           application_object = object.object
           ctx.schema.after_lazy(self.authorized?(application_object, args, ctx)) do |is_authorized|
             if is_authorized
-              # 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
-              end
+              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)
@@ -597,43 +592,6 @@ 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 && extra_name != :ast_node && respond_to?(extra_name)
@@ -704,24 +662,52 @@ module GraphQL
         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
-              extended_obj.public_send(@resolver_method)
+              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
-            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