graphql 1.10.0.pre1 → 1.10.0.pre2

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

@@ -31,10 +31,10 @@ 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.first ||= arguments[:first]
-            value.after ||= arguments[:after]
-            value.last ||= arguments[:last]
-            value.before ||= arguments[:before]
+            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?

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:)
@@ -57,6 +59,10 @@ module GraphQL
         to_h
       end
 
+      def prepare
+        self
+      end
+
       def unwrap_value(value)
         case value
         when Array
@@ -86,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
@@ -127,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,6 +7,7 @@ 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
@@ -21,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
@@ -64,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'")}

data/lib/graphql/schema/introspection_system.rb

@@ -2,24 +2,36 @@
 module GraphQL
   class Schema
     class IntrospectionSystem
-      attr_reader :schema_type, :type_type, :typename_field
+      attr_reader :types, :possible_types
 
       def initialize(schema)
         @schema = schema
+        @class_based = !!@schema.is_a?(Class)
         @built_in_namespace = GraphQL::Introspection
-        @custom_namespace = schema.introspection_namespace || @built_in_namespace
-
-        # Use to-graphql to avoid sharing with any previous instantiations
-        @schema_type = load_constant(:SchemaType).to_graphql
-        @type_type = load_constant(:TypeType).to_graphql
-        @field_type = load_constant(:FieldType).to_graphql
-        @directive_type = load_constant(:DirectiveType).to_graphql
-        @enum_value_type = load_constant(:EnumValueType).to_graphql
-        @input_value_type = load_constant(:InputValueType).to_graphql
-        @type_kind_enum = load_constant(:TypeKindEnum).to_graphql
-        @directive_location_enum = load_constant(:DirectiveLocationEnum).to_graphql
+        @custom_namespace = if @class_based
+          schema.introspection || @built_in_namespace
+        else
+          schema.introspection_namespace || @built_in_namespace
+        end
+
+        type_defns = [
+          load_constant(:SchemaType),
+          load_constant(:TypeType),
+          load_constant(:FieldType),
+          load_constant(:DirectiveType),
+          load_constant(:EnumValueType),
+          load_constant(:InputValueType),
+          load_constant(:TypeKindEnum),
+          load_constant(:DirectiveLocationEnum)
+        ]
+        @types = {}
+        @possible_types = {}
+        type_defns.each do |t|
+          @types[t.graphql_name] = t
+          @possible_types[t.graphql_name] = [t]
+        end
         @entry_point_fields =
-          if schema.disable_introspection_entry_points
+          if schema.disable_introspection_entry_points?
             {}
           else
             get_fields_from_class(class_sym: :EntryPoints)
@@ -27,19 +39,6 @@ module GraphQL
         @dynamic_fields = get_fields_from_class(class_sym: :DynamicFields)
       end
 
-      def object_types
-        [
-          @schema_type,
-          @type_type,
-          @field_type,
-          @directive_type,
-          @enum_value_type,
-          @input_value_type,
-          @type_kind_enum,
-          @directive_location_enum,
-        ]
-      end
-
       def entry_points
         @entry_point_fields.values
       end
@@ -56,25 +55,94 @@ module GraphQL
         @dynamic_fields[name]
       end
 
+      # The introspection system is prepared with a bunch of LateBoundTypes.
+      # Replace those with the objects that they refer to, since LateBoundTypes
+      # aren't handled at runtime.
+      #
+      # @api private
+      # @return void
+      def resolve_late_bindings
+        @types.each do |name, t|
+          if t.kind.fields?
+            t.fields.each do |_name, field_defn|
+              field_defn.type = resolve_late_binding(field_defn.type)
+            end
+          end
+        end
+
+        @entry_point_fields.each do |name, f|
+          f.type = resolve_late_binding(f.type)
+        end
+
+        @dynamic_fields.each do |name, f|
+          f.type = resolve_late_binding(f.type)
+        end
+        nil
+      end
+
       private
 
+      def resolve_late_binding(late_bound_type)
+        case late_bound_type
+        when GraphQL::Schema::LateBoundType
+          @schema.get_type(late_bound_type.name)
+        when GraphQL::Schema::List, GraphQL::ListType
+          resolve_late_binding(late_bound_type.of_type).to_list_type
+        when GraphQL::Schema::NonNull, GraphQL::NonNullType
+          resolve_late_binding(late_bound_type.of_type).to_non_null_type
+        when Module
+          # It's a normal type -- no change required
+          late_bound_type
+        else
+          raise "Invariant: unexpected type: #{late_bound_type} (#{late_bound_type.class})"
+        end
+      end
+
       def load_constant(class_name)
-        @custom_namespace.const_get(class_name)
+        const = @custom_namespace.const_get(class_name)
+        if @class_based
+          dup_type_class(const)
+        else
+          # Use `.to_graphql` to get a freshly-made version, not shared between schemas
+          const.to_graphql
+        end
       rescue NameError
         # Dup the built-in so that the cached fields aren't shared
-        @built_in_namespace.const_get(class_name)
+        dup_type_class(@built_in_namespace.const_get(class_name))
       end
 
       def get_fields_from_class(class_sym:)
-        object_class = load_constant(class_sym)
-        object_type_defn = object_class.to_graphql
-        extracted_field_defns = {}
-        object_type_defn.all_fields.each do |field_defn|
-          inner_resolve = field_defn.resolve_proc
-          resolve_with_instantiate = PerFieldProxyResolve.new(object_class: object_class, inner_resolve: inner_resolve)
-          extracted_field_defns[field_defn.name] = field_defn.redefine(resolve: resolve_with_instantiate)
+        object_type_defn = load_constant(class_sym)
+
+        if object_type_defn.is_a?(Module)
+          object_type_defn.fields
+        else
+          extracted_field_defns = {}
+          object_class = object_type_defn.metadata[:type_class]
+          object_type_defn.all_fields.each do |field_defn|
+            inner_resolve = field_defn.resolve_proc
+            resolve_with_instantiate = PerFieldProxyResolve.new(object_class: object_class, inner_resolve: inner_resolve)
+            extracted_field_defns[field_defn.name] = field_defn.redefine(resolve: resolve_with_instantiate)
+          end
+          extracted_field_defns
+        end
+      end
+
+      # This is probably not 100% robust -- but it has to be good enough to avoid modifying the built-in introspection types
+      def dup_type_class(type_class)
+        type_name = type_class.graphql_name
+        Class.new(type_class) do
+          # This won't be inherited like other things will
+          graphql_name(type_name)
+
+          if type_class.kind.fields?
+            type_class.fields.each do |_name, field_defn|
+              dup_field = field_defn.dup
+              dup_field.owner = self
+              add_field(dup_field)
+            end
+          end
         end
-        extracted_field_defns
       end
 
       class PerFieldProxyResolve