graphql 1.8.0 → 1.12.12

data/lib/graphql/schema/field_extension.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    # Extend this class to make field-level customizations to resolve behavior.
+    #
+    # When a extension is added to a field with `extension(MyExtension)`, a `MyExtension` instance
+    # is created, and its hooks are applied whenever that field is called.
+    #
+    # The instance is frozen so that instance variables aren't modified during query execution,
+    # which could cause all kinds of issues due to race conditions.
+    class FieldExtension
+      # @return [GraphQL::Schema::Field]
+      attr_reader :field
+
+      # @return [Object]
+      attr_reader :options
+
+      # Called when the extension is mounted with `extension(name, options)`.
+      # The instance is frozen to avoid improper use of state during execution.
+      # @param field [GraphQL::Schema::Field] The field where this extension was mounted
+      # @param options [Object] The second argument to `extension`, or `{}` if nothing was passed.
+      def initialize(field:, options:)
+        @field = field
+        @options = options || {}
+        apply
+        freeze
+      end
+
+      # Called when this extension is attached to a field.
+      # The field definition may be extended during this method.
+      # @return [void]
+      def apply
+      end
+
+      # Called before resolving {#field}. It should either:
+      #
+      # - `yield` values to continue execution; OR
+      # - return something else to shortcut field execution.
+      #
+      # Whatever this method returns will be used for execution.
+      #
+      # @param object [Object] The object the field is being resolved on
+      # @param arguments [Hash] Ruby keyword arguments for resolving this field
+      # @param context [Query::Context] the context for this query
+      # @yieldparam object [Object] The object to continue resolving the field on
+      # @yieldparam arguments [Hash] The keyword arguments to continue resolving with
+      # @yieldparam memo [Object] Any extension-specific value which will be passed to {#after_resolve} later
+      # @return [Object] The return value for this field.
+      def resolve(object:, arguments:, context:)
+        yield(object, arguments, nil)
+      end
+
+      # Called after {#field} was resolved, and after any lazy values (like `Promise`s) were synced,
+      # but before the value was added to the GraphQL response.
+      #
+      # Whatever this hook returns will be used as the return value.
+      #
+      # @param object [Object] The object the field is being resolved on
+      # @param arguments [Hash] Ruby keyword arguments for resolving this field
+      # @param context [Query::Context] the context for this query
+      # @param value [Object] Whatever the field previously returned
+      # @param memo [Object] The third value yielded by {#resolve}, or `nil` if there wasn't one
+      # @return [Object] The return value for this field.
+      def after_resolve(object:, arguments:, context:, value:, memo:)
+        value
+      end
+    end
+  end
+end

data/lib/graphql/schema/find_inherited_value.rb

@@ -0,0 +1,35 @@
+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)
+        if self.is_a?(Class)
+          superclass.respond_to?(method_name, true) ? superclass.send(method_name) : default_value
+        else
+          ancestors_except_self = ancestors
+          ancestors_except_self.delete(self)
+          ancestors_except_self.each do |ancestor|
+            if ancestor.respond_to?(method_name, true)
+              return ancestor.send(method_name)
+            end
+          end
+          default_value
+        end
+      end
+    end
+  end
+end

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,29 +5,101 @@ module GraphQL
       extend GraphQL::Schema::Member::AcceptsDefinition
       extend Forwardable
       extend GraphQL::Schema::Member::HasArguments
+      extend GraphQL::Schema::Member::HasArguments::ArgumentObjectLoader
+      extend GraphQL::Schema::Member::ValidatesInput
+      extend GraphQL::Schema::Member::HasValidators
 
-      def initialize(values, context:, defaults_used:)
+      include GraphQL::Dig
+
+      def initialize(arguments = nil, ruby_kwargs: nil, context:, defaults_used:)
         @context = context
-        @arguments = self.class.arguments_class.new(values, context: context, defaults_used: defaults_used)
-        # Symbolized, underscored hash:
-        @ruby_style_hash = @arguments.to_kwargs
+        if ruby_kwargs
+          @ruby_style_hash = ruby_kwargs
+          @arguments = arguments
+        else
+          @arguments = self.class.arguments_class.new(arguments, context: context, defaults_used: defaults_used)
+          # Symbolized, underscored hash:
+          @ruby_style_hash = @arguments.to_kwargs
+        end
         # Apply prepares, not great to have it duplicated here.
-        self.class.arguments.each do |name, arg_defn|
+        maybe_lazies = []
+        self.class.arguments.each_value do |arg_defn|
           ruby_kwargs_key = arg_defn.keyword
-          if @ruby_style_hash.key?(ruby_kwargs_key) && arg_defn.prepare
-            @ruby_style_hash[ruby_kwargs_key] = arg_defn.prepare_value(self, @ruby_style_hash[ruby_kwargs_key])
+
+          if @ruby_style_hash.key?(ruby_kwargs_key)
+            loads = arg_defn.loads
+            # Resolvers do this loading themselves;
+            # With the interpreter, it's done during `coerce_arguments`
+            if loads && !arg_defn.from_resolver? && !context.interpreter?
+              value = @ruby_style_hash[ruby_kwargs_key]
+              loaded_value = if arg_defn.type.list?
+                value.map { |val| load_application_object(arg_defn, loads, val, context) }
+              else
+                load_application_object(arg_defn, loads, value, context)
+              end
+              maybe_lazies << context.schema.after_lazy(loaded_value) do |loaded_value|
+                overwrite_argument(ruby_kwargs_key, loaded_value)
+              end
+            end
+
+            # Weirdly, procs are applied during coercion, but not methods.
+            # Probably because these methods require a `self`.
+            if arg_defn.prepare.is_a?(Symbol) || context.nil? || !context.interpreter?
+              prepared_value = arg_defn.prepare_value(self, @ruby_style_hash[ruby_kwargs_key])
+              overwrite_argument(ruby_kwargs_key, prepared_value)
+            end
           end
         end
+
+        @maybe_lazies = maybe_lazies
       end
 
       # @return [GraphQL::Query::Context] The context for this query
       attr_reader :context
 
-      # @return [GraphQL::Query::Arguments] The underlying arguments instance
+      # @return [GraphQL::Query::Arguments, GraphQL::Execution::Interpereter::Arguments] The underlying arguments instance
       attr_reader :arguments
 
       # Ruby-like hash behaviors, read-only
-      def_delegators :@ruby_style_hash, :to_h, :keys, :values, :each, :any?
+      def_delegators :@ruby_style_hash, :keys, :values, :each, :map, :any?, :empty?
+
+      def to_h
+        @ruby_style_hash.inject({}) do |h, (key, value)|
+          h.merge(key => unwrap_value(value))
+        end
+      end
+
+      def to_hash
+        to_h
+      end
+
+      def prepare
+        if context
+          context.schema.after_any_lazies(@maybe_lazies) do
+            object = context[:current_object]
+            # Pass this object's class with `as` so that messages are rendered correctly from inherited validators
+            Schema::Validator.validate!(self.class.validators, object, context, @ruby_style_hash, as: self.class)
+            self
+          end
+        else
+          self
+        end
+      end
+
+      def unwrap_value(value)
+        case value
+        when Array
+          value.map { |item| unwrap_value(item) }
+        when Hash
+          value.inject({}) do |h, (key, value)|
+            h.merge(key => unwrap_value(value))
+          end
+        when InputObject
+          value.to_h
+        else
+          value
+        end
+      end
 
       # Lookup a key on this object, it accepts new-style underscored symbols
       # Or old-style camelized identifiers.
@@ -35,13 +107,15 @@ module GraphQL
       def [](key)
         if @ruby_style_hash.key?(key)
           @ruby_style_hash[key]
-        else
+        elsif @arguments
           @arguments[key]
+        else
+          nil
         end
       end
 
       def key?(key)
-        @ruby_style_hash.key?(key) || @arguments.key?(key)
+        @ruby_style_hash.key?(key) || (@arguments && @arguments.key?(key)) || false
       end
 
       # A copy of the Ruby-style hash
@@ -53,13 +127,15 @@ module GraphQL
         # @return [Class<GraphQL::Arguments>]
         attr_accessor :arguments_class
 
-        def argument(*args)
-          argument_defn = super
+        def argument(*args, **kwargs, &block)
+          argument_defn = super(*args, **kwargs, &block)
           # Add a method access
-          arg_name = argument_defn.graphql_definition.name
-          define_method(Member::BuildType.underscore(arg_name)) do
-            @arguments.public_send(arg_name)
-          end
+          method_name = argument_defn.keyword
+          class_eval <<-RUBY, __FILE__, __LINE__
+            def #{method_name}
+              self[#{method_name.inspect}]
+            end
+          RUBY
         end
 
         def to_graphql
@@ -68,6 +144,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
@@ -81,6 +158,102 @@ 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
+
+          if !(input.respond_to?(:to_h) || input.respond_to?(:to_unsafe_h))
+            # 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
+
+          # Inject missing required arguments
+          missing_required_inputs = self.arguments.reduce({}) do |m, (argument_name, argument)|
+            if !input.key?(argument_name) && argument.type.non_null? && warden.get_argument(self, argument_name)
+              m[argument_name] = nil
+            end
+
+            m
+          end
+
+
+          [input, missing_required_inputs].each do |args_to_validate|
+            args_to_validate.each do |argument_name, value|
+              argument = warden.get_argument(self, argument_name)
+              # Items in the input that are unexpected
+              unless argument
+                result.add_problem("Field is not defined on #{self.graphql_name}", [argument_name])
+                next
+              end
+              # Items in the input that are expected, but have invalid values
+              argument_result = argument.type.validate_input(value, ctx)
+              result.merge_result!(argument_name, argument_result) unless argument_result.valid?
+            end
+          end
+
+          result
+        end
+
+        def coerce_input(value, ctx)
+          if value.nil?
+            return nil
+          end
+
+          arguments = coerce_arguments(nil, value, ctx)
+
+          ctx.schema.after_lazy(arguments) do |resolved_arguments|
+            if resolved_arguments.is_a?(GraphQL::Error)
+              raise resolved_arguments
+            else
+              input_obj_instance = self.new(resolved_arguments, ruby_kwargs: resolved_arguments.keyword_arguments, context: ctx, defaults_used: nil)
+              input_obj_instance.prepare
+            end
+          end
+        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 :snake_symbols, and convert them to the camelStrings
+          value = value.reduce({}) { |memo, (k, v)| memo[Member::BuildType.camelize(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
+
+      private
+
+      def overwrite_argument(key, value)
+        # Argument keywords come in frozen from the interpreter, dup them before modifying them.
+        if @ruby_style_hash.frozen?
+          @ruby_style_hash = @ruby_style_hash.dup
+        end
+        @ruby_style_hash[key] = value
       end
     end
   end

data/lib/graphql/schema/interface.rb

@@ -7,8 +7,15 @@ 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
+        include GraphQL::Schema::Member::HasUnresolvedTypeError
+        include GraphQL::Schema::Member::HasDirectives
 
         # Methods defined in this block will be:
         # - Added as class methods to this interface
@@ -17,12 +24,44 @@ module GraphQL
           self::DefinitionMethods.module_eval(&block)
         end
 
+        # @see {Schema::Warden} hides interfaces without visible implementations
+        def visible?(context)
+          true
+        end
+
+        # The interface is accessible if any of its possible types are accessible
+        def accessible?(context)
+          context.schema.possible_types(self, context).each do |type|
+            if context.schema.accessible?(type, context)
+              return true
+            end
+          end
+          false
+        end
+
+        def type_membership_class(membership_class = nil)
+          if membership_class
+            @type_membership_class = membership_class
+          else
+            @type_membership_class || find_inherited_value(:type_membership_class, GraphQL::Schema::TypeMembership)
+          end
+        end
+
         # Here's the tricky part. Make sure behavior keeps making its way down the inheritance chain.
         def included(child_class)
           if !child_class.is_a?(Class)
             # In this case, it's been included into another interface.
             # This is how interface inheritance is implemented
 
+            # We need this before we can call `own_interfaces`
+            child_class.extend(Schema::Interface::DefinitionMethods)
+
+            child_class.type_membership_class(self.type_membership_class)
+            child_class.own_interfaces << self
+            child_class.interfaces.reverse_each do |interface_defn|
+              child_class.extend(interface_defn::DefinitionMethods)
+            end
+
             # Use an instance variable to tell whether it's been included previously or not;
             # You can't use constant detection because constants are brought into scope
             # by `include`, which has already happened at this point.
@@ -32,13 +71,14 @@ module GraphQL
               child_class.const_set(:DefinitionMethods, defn_methods_module)
               child_class.extend(child_class::DefinitionMethods)
             end
-
-            # We need this before we can call `own_interfaces`
-            child_class.extend(Schema::Interface::DefinitionMethods)
-
-            child_class.own_interfaces << self
-            child_class.interfaces.each do |interface_defn|
-              child_class.extend(interface_defn::DefinitionMethods)
+            child_class.introspection(introspection)
+            child_class.description(description)
+            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(...)`
@@ -66,6 +106,8 @@ module GraphQL
           type_defn.name = graphql_name
           type_defn.description = description
           type_defn.orphan_types = orphan_types
+          type_defn.type_membership_class = self.type_membership_class
+          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