graphql 1.10.8 → 1.11.0

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/enum.rb

@@ -23,6 +23,9 @@ module GraphQL
       extend GraphQL::Schema::Member::AcceptsDefinition
       extend GraphQL::Schema::Member::ValidatesInput
 
+      class UnresolvedValueError < GraphQL::EnumType::UnresolvedValueError
+      end
+
       class << self
         # Define a value for this enum
         # @param graphql_name [String, Symbol] the GraphQL value for this, usually `SCREAMING_CASE`
@@ -94,7 +97,7 @@ module GraphQL
           if enum_value
             enum_value.graphql_name
           else
-            raise(GraphQL::EnumType::UnresolvedValueError, "Can't resolve enum #{graphql_name} for #{value.inspect}")
+            raise(self::UnresolvedValueError, "Can't resolve enum #{graphql_name} for #{value.inspect}")
           end
         end
 
@@ -112,6 +115,11 @@ module GraphQL
           end
         end
 
+        def inherited(child_class)
+          child_class.const_set(:UnresolvedValueError, Class.new(Schema::Enum::UnresolvedValueError))
+          super
+        end
+
         private
 
         def own_values

data/lib/graphql/schema/field.rb

@@ -191,9 +191,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 +238,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 +252,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 +297,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 +543,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)
@@ -556,34 +565,13 @@ module GraphQL
         begin
           # Unwrap the GraphQL object to get the application object.
           application_object = object.object
-          if self.authorized?(application_object, args, 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
@@ -595,43 +583,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)
@@ -672,6 +623,8 @@ module GraphQL
                 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
@@ -700,24 +653,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

@@ -31,6 +31,7 @@ module GraphQL
           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]
@@ -41,7 +42,7 @@ module GraphQL
             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)
+            context.schema.connections.wrap(field, object.object, value, arguments, context, wrappers: wrappers)
           else
             if object.is_a?(GraphQL::Schema::Object)
               object = object.object

data/lib/graphql/schema/input_object.rb

@@ -21,10 +21,8 @@ module GraphQL
           @ruby_style_hash = @arguments.to_kwargs
         end
         # Apply prepares, not great to have it duplicated here.
-        @arguments_by_keyword = {}
         maybe_lazies = []
-        self.class.arguments.each do |name, arg_defn|
-          @arguments_by_keyword[arg_defn.keyword] = arg_defn
+        self.class.arguments.each_value do |arg_defn|
           ruby_kwargs_key = arg_defn.keyword
 
           if @ruby_style_hash.key?(ruby_kwargs_key)

data/lib/graphql/schema/interface.rb

@@ -14,6 +14,7 @@ module GraphQL
         include GraphQL::Schema::Member::RelayShortcuts
         include GraphQL::Schema::Member::Scoped
         include GraphQL::Schema::Member::HasAstNode
+        include GraphQL::Schema::Member::HasUnresolvedTypeError
 
         # Methods defined in this block will be:
         # - Added as class methods to this interface
@@ -74,6 +75,10 @@ module GraphQL
             if overridden_graphql_name
               child_class.graphql_name(overridden_graphql_name)
             end
+            # If interfaces are mixed into each other, only define this class once
+            if !child_class.const_defined?(:UnresolvedTypeError, false)
+              add_unresolved_type_error(child_class)
+            end
           elsif child_class < GraphQL::Schema::Object
             # This is being included into an object type, make sure it's using `implements(...)`
             backtrace_line = caller(0, 10).find { |line| line.include?("schema/object.rb") && line.include?("in `implements'")}

data/lib/graphql/schema/list.rb

@@ -44,7 +44,8 @@ module GraphQL
         if value.nil?
           nil
         else
-          ensure_array(value).map { |item| item.nil? ? item : of_type.coerce_input(item, ctx) }
+          coerced = ensure_array(value).map { |item| item.nil? ? item : of_type.coerce_input(item, ctx) }
+          ctx.schema.after_any_lazies(coerced, &:itself)
         end
       end
 

data/lib/graphql/schema/loader.rb

@@ -157,6 +157,7 @@ module GraphQL
               type: type_resolver.call(field_hash["type"]),
               description: field_hash["description"],
               null: true,
+              camelize: false,
             ) do
               if field_hash["args"].any?
                 loader.build_arguments(self, field_hash["args"], type_resolver)
@@ -171,6 +172,8 @@ module GraphQL
               type: type_resolver.call(arg["type"]),
               description: arg["description"],
               required: false,
+              method_access: false,
+              camelize: false,
             }
 
             if arg["defaultValue"]

data/lib/graphql/schema/member.rb

@@ -5,6 +5,7 @@ require 'graphql/schema/member/cached_graphql_definition'
 require 'graphql/schema/member/graphql_type_names'
 require 'graphql/schema/member/has_ast_node'
 require 'graphql/schema/member/has_path'
+require 'graphql/schema/member/has_unresolved_type_error'
 require 'graphql/schema/member/relay_shortcuts'
 require 'graphql/schema/member/scoped'
 require 'graphql/schema/member/type_system_helpers'

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

@@ -135,6 +135,12 @@ module GraphQL
           end
         end
 
+        def arguments_statically_coercible?
+          return @arguments_statically_coercible if defined?(@arguments_statically_coercible)
+
+          @arguments_statically_coercible = arguments.each_value.all?(&:statically_coercible?)
+        end
+
         module ArgumentClassAccessor
           def argument_class(new_arg_class = nil)
             if new_arg_class

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

@@ -47,7 +47,7 @@ module GraphQL
         # A list of GraphQL-Ruby keywords.
         #
         # @api private
-        GRAPHQL_RUBY_KEYWORDS = [:context, :object, :method]
+        GRAPHQL_RUBY_KEYWORDS = [:context, :object, :method, :raw_value]
 
         # A list of field names that we should advise users to pick a different
         # resolve method name.

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      # Set up a type-specific error to make debugging & bug tracker integration better
+      module HasUnresolvedTypeError
+        private
+        def add_unresolved_type_error(child_class)
+          child_class.const_set(:UnresolvedTypeError, Class.new(GraphQL::UnresolvedTypeError))
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/object.rb

@@ -71,6 +71,13 @@ module GraphQL
       end
 
       class << self
+        # 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))
+          super
+        end
+
         def implements(*new_interfaces, **options)
           new_memberships = []
           new_interfaces.each do |int|

data/lib/graphql/schema/resolver.rb

@@ -250,6 +250,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 +274,7 @@ module GraphQL
             null: null,
             complexity: complexity,
             extensions: extensions,
+            broadcastable: broadcastable?,
           }
         end