graphql 1.10.13 → 1.11.3

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

data/lib/graphql/schema/field/connection_extension.rb

@@ -22,39 +22,49 @@ module GraphQL
         end
 
         def after_resolve(value:, object:, arguments:, context:, memo:)
-          if value.is_a? GraphQL::ExecutionError
-            # This isn't even going to work because context doesn't have ast_node anymore
-            context.add_error(value)
-            nil
-          elsif value.nil?
-            nil
-          elsif value.is_a?(GraphQL::Pagination::Connection)
-            # update the connection with some things that may not have been provided
-            value.context ||= context
-            value.first_value ||= arguments[:first]
-            value.after_value ||= arguments[:after]
-            value.last_value ||= arguments[:last]
-            value.before_value ||= arguments[:before]
-            if field.has_max_page_size? && !value.has_max_page_size_override?
-              value.max_page_size = field.max_page_size
+          # rename some inputs to avoid conflicts inside the block
+          maybe_lazy = value
+          value = nil
+          context.schema.after_lazy(maybe_lazy) do |resolved_value|
+            value = resolved_value
+            if value.is_a? GraphQL::ExecutionError
+              # This isn't even going to work because context doesn't have ast_node anymore
+              context.add_error(value)
+              nil
+            elsif value.nil?
+              nil
+            elsif value.is_a?(GraphQL::Pagination::Connection)
+              # update the connection with some things that may not have been provided
+              value.context ||= context
+              value.parent ||= object.object
+              value.first_value ||= arguments[:first]
+              value.after_value ||= arguments[:after]
+              value.last_value ||= arguments[:last]
+              value.before_value ||= arguments[:before]
+              if field.has_max_page_size? && !value.has_max_page_size_override?
+                value.max_page_size = field.max_page_size
+              end
+              if (custom_t = context.schema.connections.edge_class_for_field(@field))
+                value.edge_class = custom_t
+              end
+              value
+            elsif context.schema.new_connections?
+              wrappers = context.namespace(:connections)[:all_wrappers] ||= context.schema.connections.all_wrappers
+              context.schema.connections.wrap(field, object.object, value, arguments, context, wrappers: wrappers)
+            else
+              if object.is_a?(GraphQL::Schema::Object)
+                object = object.object
+              end
+              connection_class = GraphQL::Relay::BaseConnection.connection_for_nodes(value)
+              connection_class.new(
+                value,
+                arguments,
+                field: field,
+                max_page_size: field.max_page_size,
+                parent: object,
+                context: context,
+              )
             end
-            value
-          elsif context.schema.new_connections?
-            wrappers = context.namespace(:connections)[:all_wrappers] ||= context.schema.connections.all_wrappers
-            context.schema.connections.wrap(field, value, arguments, context, wrappers: wrappers)
-          else
-            if object.is_a?(GraphQL::Schema::Object)
-              object = object.object
-            end
-            connection_class = GraphQL::Relay::BaseConnection.connection_for_nodes(value)
-            connection_class.new(
-              value,
-              arguments,
-              field: field,
-              max_page_size: field.max_page_size,
-              parent: object,
-              context: context,
-            )
           end
         end
       end

data/lib/graphql/schema/loader.rb

@@ -25,8 +25,15 @@ module GraphQL
           types[type["name"]] = type_object
         end
 
+        directives = []
+        schema.fetch("directives", []).each do |directive|
+          next if GraphQL::Schema.default_directives.include?(directive.fetch("name"))
+          directives << define_directive(directive, type_resolver)
+        end
+
         Class.new(GraphQL::Schema) do
           orphan_types(types.values)
+          directives(directives)
 
           def self.resolve_type(*)
             raise(GraphQL::RequiredImplementationMissingError, "This schema was loaded from string, so it can't resolve types for objects")
@@ -98,7 +105,7 @@ module GraphQL
                 value(
                   enum_value["name"],
                   description: enum_value["description"],
-                  deprecation_reason: enum_value["deprecation_reason"],
+                  deprecation_reason: enum_value["deprecationReason"],
                 )
               end
             end
@@ -147,6 +154,16 @@ module GraphQL
           end
         end
 
+        def define_directive(directive, type_resolver)
+          loader = self
+          Class.new(GraphQL::Schema::Directive) do
+            graphql_name(directive["name"])
+            description(directive["description"])
+            locations(*directive["locations"].map(&:to_sym))
+            loader.build_arguments(self, directive["args"], type_resolver)
+          end
+        end
+
         public
 
         def build_fields(type_defn, fields, type_resolver)
@@ -156,6 +173,7 @@ module GraphQL
               field_hash["name"],
               type: type_resolver.call(field_hash["type"]),
               description: field_hash["description"],
+              deprecation_reason: field_hash["deprecationReason"],
               null: true,
               camelize: false,
             ) do

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

@@ -60,7 +60,9 @@ module GraphQL
 
         # @return [GraphQL::Schema::Argument, nil] Argument defined on this thing, fetched by name.
         def get_argument(argument_name)
-          if (a = own_arguments[argument_name])
+          a = own_arguments[argument_name]
+
+          if a || !self.is_a?(Class)
             a
           else
             for ancestor in ancestors

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

@@ -47,20 +47,22 @@ module GraphQL
         # A list of GraphQL-Ruby keywords.
         #
         # @api private
-        GRAPHQL_RUBY_KEYWORDS = [:context, :object, :method, :raw_value]
+        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.resolver_method) && field_defn.original_name == field_defn.resolver_method && field_defn.method_conflict_warning?
-            warn "#{self.graphql_name}'s `field :#{field_defn.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."
+        def add_field(field_defn, method_conflict_warning: field_defn.method_conflict_warning?)
+          # Check that `field_defn.original_name` equals `resolver_method` and `method_sym` --
+          # that shows that no override value was given manually.
+          if method_conflict_warning && CONFLICT_FIELD_NAMES.include?(field_defn.resolver_method) && field_defn.original_name == field_defn.resolver_method && field_defn.original_name == field_defn.method_sym
+            warn(conflict_field_name_warning(field_defn))
           end
           own_fields[field_defn.name] = field_defn
           nil
@@ -92,6 +94,14 @@ module GraphQL
         def own_fields
           @own_fields ||= {}
         end
+
+        private
+
+        # @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/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/object.rb

@@ -74,7 +74,7 @@ module GraphQL
         # 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, Class.new(GraphQL::InvalidNullError))
+          child_class.const_set(:InvalidNullError, GraphQL::InvalidNullError.subclass_for(child_class))
           super
         end
 

data/lib/graphql/schema/resolver.rb

@@ -40,6 +40,7 @@ module GraphQL
           @arguments_by_keyword[arg.keyword] = arg
         end
         @arguments_loads_as_type = self.class.arguments_loads_as_type
+        @prepared_arguments = nil
       end
 
       # @return [Object] The application object this field is being resolved on
@@ -51,6 +52,10 @@ module GraphQL
       # @return [GraphQL::Schema::Field]
       attr_reader :field
 
+      def arguments
+        @prepared_arguments || raise("Arguments have not been prepared yet, still waiting for #load_arguments to resolve. (Call `.arguments` later in the code.)")
+      end
+
       # This method is _actually_ called by the runtime,
       # it does some preparation and then eventually calls
       # the user-defined `#resolve` method.
@@ -74,6 +79,7 @@ module GraphQL
             # for that argument, or may return a lazy object
             load_arguments_val = load_arguments(args)
             context.schema.after_lazy(load_arguments_val) do |loaded_args|
+              @prepared_arguments = loaded_args
               # Then call `authorized?`, which may raise or may return a lazy object
               authorized_val = if loaded_args.any?
                 authorized?(**loaded_args)
@@ -250,6 +256,19 @@ module GraphQL
           @complexity || (superclass.respond_to?(:complexity) ? superclass.complexity : 1)
         end
 
+        def broadcastable(new_broadcastable)
+          @broadcastable = new_broadcastable
+        end
+
+        # @return [Boolean, nil]
+        def broadcastable?
+          if defined?(@broadcastable)
+            @broadcastable
+          else
+            (superclass.respond_to?(:broadcastable?) ? superclass.broadcastable? : nil)
+          end
+        end
+
         def field_options
           {
             type: type_expr,
@@ -261,6 +280,7 @@ module GraphQL
             null: null,
             complexity: complexity,
             extensions: extensions,
+            broadcastable: broadcastable?,
           }
         end