graphql 1.9.17 → 1.10.0

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

@@ -28,6 +28,17 @@ module GraphQL
             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]
+            value.max_page_size ||= field.max_page_size
+            value
+          elsif context.schema.new_connections?
+            context.schema.connections.wrap(field, value, arguments, context)
           else
             if object.is_a?(GraphQL::Schema::Object)
               object = object.object
@@ -43,7 +54,6 @@ module GraphQL
             )
           end
         end
-
       end
     end
   end

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
@@ -35,9 +37,9 @@ module GraphQL
       attr_reader :resolver_method
 
       # @return [Class] The type that this field belongs to
-      attr_reader :owner
+      attr_accessor :owner
 
-      # @return [Symobol] the original name of the field, passed in by the user
+      # @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
@@ -51,7 +53,7 @@ module GraphQL
       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 +154,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
@@ -175,7 +185,9 @@ 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 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: nil, scope: nil, introspection: false, camelize: true, trace: nil, complexity: 1, ast_node: nil, extras: [], extensions: EMPTY_ARRAY, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, arguments: EMPTY_HASH, &definition_block)
         if name.nil?
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
         end
@@ -191,8 +203,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."
@@ -236,14 +249,14 @@ module GraphQL
         @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
+            own_arguments[name] = arg
           end
         end
 
@@ -347,7 +360,7 @@ module GraphQL
         end
       end
 
-      def complexity(new_complexity)
+      def complexity(new_complexity = nil)
         case new_complexity
         when Proc
           if new_complexity.parameters.size != 3
@@ -360,6 +373,8 @@ module GraphQL
           end
         when Numeric
           @complexity = new_complexity
+        when nil
+          @complexity
         else
           raise("Invalid complexity: #{new_complexity.inspect} on #{@name}")
         end
@@ -416,6 +431,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 +449,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 +486,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 +512,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, 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,7 +544,7 @@ module GraphQL
         begin
           # Unwrap the GraphQL object to get the application object.
           application_object = object.object
-          if self.authorized?(application_object, ctx)
+          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
@@ -594,7 +622,7 @@ module GraphQL
 
       # @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)
@@ -661,7 +689,7 @@ module GraphQL
       # Written iteratively to avoid big stack traces.
       # @return [Object] Whatever the
       def with_extensions(obj, args, ctx)
-        if @extensions.empty?
+        if @extensions.nil?
           yield(obj, args)
         else
           # Save these so that the originals can be re-given to `after_resolve` handlers.

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

data/lib/graphql/schema/input_object.rb

@@ -5,6 +5,8 @@ module GraphQL
       extend GraphQL::Schema::Member::AcceptsDefinition
       extend Forwardable
       extend GraphQL::Schema::Member::HasArguments
+      extend GraphQL::Schema::Member::ValidatesInput
+
       include GraphQL::Dig
 
       def initialize(values = nil, ruby_kwargs: nil, context:, defaults_used:)
@@ -26,7 +28,7 @@ module GraphQL
           if @ruby_style_hash.key?(ruby_kwargs_key) && loads && !arg_defn.from_resolver?
             value = @ruby_style_hash[ruby_kwargs_key]
             @ruby_style_hash[ruby_kwargs_key] = if arg_defn.type.list?
-              GraphQL::Execution::Lazy.all(value.map { |val| load_application_object(arg_defn, loads, val) })
+              value.map { |val| load_application_object(arg_defn, loads, val) }
             else
               load_application_object(arg_defn, loads, value)
             end
@@ -90,7 +92,7 @@ module GraphQL
       end
 
       def key?(key)
-        @ruby_style_hash.key?(key) || (@arguments && @arguments.key?(key))
+        @ruby_style_hash.key?(key) || (@arguments && @arguments.key?(key)) || false
       end
 
       # A copy of the Ruby-style hash
@@ -117,6 +119,7 @@ module GraphQL
           type_defn.description = description
           type_defn.metadata[:type_class] = self
           type_defn.mutation = mutation
+          type_defn.ast_node = ast_node
           arguments.each do |name, arg|
             type_defn.arguments[arg.graphql_definition.name] = arg.graphql_definition
           end
@@ -130,6 +133,108 @@ module GraphQL
         def kind
           GraphQL::TypeKinds::INPUT_OBJECT
         end
+
+        # @api private
+        INVALID_OBJECT_MESSAGE = "Expected %{object} to be a key-value object responding to `to_h` or `to_unsafe_h`."
+
+
+        def validate_non_null_input(input, ctx)
+          result = GraphQL::Query::InputValidationResult.new
+
+          warden = ctx.warden
+
+          if input.is_a?(Array)
+            result.add_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
+            return result
+          end
+
+          # We're not actually _using_ the coerced result, we're just
+          # using these methods to make sure that the object will
+          # behave like a hash below, when we call `each` on it.
+          begin
+            input.to_h
+          rescue
+            begin
+              # Handle ActionController::Parameters:
+              input.to_unsafe_h
+            rescue
+              # We're not sure it'll act like a hash, so reject it:
+              result.add_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
+              return result
+            end
+          end
+
+          visible_arguments_map = warden.arguments(self).reduce({}) { |m, f| m[f.name] = f; m}
+
+          # Items in the input that are unexpected
+          input.each do |name, value|
+            if visible_arguments_map[name].nil?
+              result.add_problem("Argument is not defined on #{self.graphql_name}", [name])
+            end
+          end
+
+          # Items in the input that are expected, but have invalid values
+          visible_arguments_map.map do |name, argument|
+            argument_result = argument.type.validate_input(input[name], ctx)
+            if !argument_result.valid?
+              result.merge_result!(name, argument_result)
+            end
+          end
+
+          result
+        end
+
+        def coerce_input(value, ctx)
+          input_values = {}
+
+          arguments.each do |name, argument_defn|
+            arg_key = argument_defn.keyword
+            has_value = false
+            # Accept either string or symbol
+            field_value = if value.key?(name)
+              has_value = true
+              value[name]
+            elsif value.key?(arg_key)
+              has_value = true
+              value[arg_key]
+            elsif argument_defn.default_value?
+              has_value = true
+              argument_defn.default_value
+            else
+              nil
+            end
+            # Only continue if some value was found for this argument
+            if has_value
+              coerced_value = argument_defn.type.coerce_input(field_value, ctx)
+              prepared_value = argument_defn.prepare_value(nil, coerced_value, context: ctx)
+              input_values[arg_key] = prepared_value
+            end
+          end
+
+          input_values
+        end
+
+        # It's funny to think of a _result_ of an input object.
+        # This is used for rendering the default value in introspection responses.
+        def coerce_result(value, ctx)
+          # Allow the application to provide values as :symbols, and convert them to the strings
+          value = value.reduce({}) { |memo, (k, v)| memo[k.to_s] = v; memo }
+
+          result = {}
+
+          arguments.each do |input_key, input_field_defn|
+            input_value = value[input_key]
+            if value.key?(input_key)
+              result[input_key] = if input_value.nil?
+                nil
+              else
+                input_field_defn.type.coerce_result(input_value, ctx)
+              end
+            end
+          end
+
+          result
+        end
       end
     end
   end

data/lib/graphql/schema/interface.rb

@@ -7,11 +7,13 @@ module GraphQL
         include GraphQL::Schema::Member::CachedGraphQLDefinition
         include GraphQL::Relay::TypeExtensions
         include GraphQL::Schema::Member::BaseDSLMethods
+        # ConfigurationExtension's responsibilities are in `def included` below
         include GraphQL::Schema::Member::TypeSystemHelpers
         include GraphQL::Schema::Member::HasFields
         include GraphQL::Schema::Member::HasPath
         include GraphQL::Schema::Member::RelayShortcuts
         include GraphQL::Schema::Member::Scoped
+        include GraphQL::Schema::Member::HasAstNode
 
         # Methods defined in this block will be:
         # - Added as class methods to this interface
@@ -20,14 +22,9 @@ module GraphQL
           self::DefinitionMethods.module_eval(&block)
         end
 
-        # The interface is visible if any of its possible types are visible
+        # @see {Schema::Warden} hides interfaces without visible implementations
         def visible?(context)
-          context.schema.possible_types(self).each do |type|
-            if context.schema.visible?(type, context)
-              return true
-            end
-          end
-          false
+          true
         end
 
         # The interface is accessible if any of its possible types are accessible
@@ -63,6 +60,11 @@ module GraphQL
               child_class.const_set(:DefinitionMethods, defn_methods_module)
               child_class.extend(child_class::DefinitionMethods)
             end
+            child_class.introspection(introspection)
+            child_class.description(description)
+            if overridden_graphql_name
+              child_class.graphql_name(overridden_graphql_name)
+            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'")}
@@ -89,6 +91,7 @@ module GraphQL
           type_defn.name = graphql_name
           type_defn.description = description
           type_defn.orphan_types = orphan_types
+          type_defn.ast_node = ast_node
           fields.each do |field_name, field_inst|
             field_defn = field_inst.graphql_definition
             type_defn.fields[field_defn.name] = field_defn