graphql 1.10.6 → 1.10.11

data/lib/graphql/schema/list.rb

@@ -31,6 +31,11 @@ module GraphQL
         nil
       end
 
+      # Also for implementing introspection
+      def description
+        nil
+      end
+
       def coerce_result(value, ctx)
         value.map { |i| i.nil? ? nil : of_type.coerce_result(i, ctx) }
       end
@@ -39,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

@@ -5,18 +5,19 @@ module GraphQL
     # to make a schema. This schema is missing some important details like
     # `resolve` functions, but it does include the full type system,
     # so you can use it to validate queries.
+    #
+    # @see GraphQL::Schema.from_introspection for a public API
     module Loader
       extend self
 
       # Create schema with the result of an introspection query.
       # @param introspection_result [Hash] A response from {GraphQL::Introspection::INTROSPECTION_QUERY}
-      # @return [GraphQL::Schema] the schema described by `input`
-      # @deprecated Use {GraphQL::Schema.from_introspection} instead
+      # @return [Class] the schema described by `input`
       def load(introspection_result)
         schema = introspection_result.fetch("data").fetch("__schema")
 
         types = {}
-        type_resolver = ->(type) { -> { resolve_type(types, type) } }
+        type_resolver = ->(type) { resolve_type(types, type) }
 
         schema.fetch("types").each do |type|
           next if type.fetch("name").start_with?("__")
@@ -24,18 +25,22 @@ module GraphQL
           types[type["name"]] = type_object
         end
 
-        kargs = { orphan_types: types.values, resolve_type: NullResolveType }
-        [:query, :mutation, :subscription].each do |root|
-          type = schema["#{root}Type"]
-          kargs[root] = types.fetch(type.fetch("name")) if type
-        end
+        Class.new(GraphQL::Schema) do
+          orphan_types(types.values)
 
-        Schema.define(**kargs, raise_definition_error: true)
-      end
+          def self.resolve_type(*)
+            raise(GraphQL::RequiredImplementationMissingError, "This schema was loaded from string, so it can't resolve types for objects")
+          end
 
-      NullResolveType = ->(type, obj, ctx) {
-        raise(GraphQL::RequiredImplementationMissingError, "This schema was loaded from string, so it can't resolve types for objects")
-      }
+          [:query, :mutation, :subscription].each do |root|
+            type = schema["#{root}Type"]
+            if type
+              type_defn = types.fetch(type.fetch("name"))
+              self.public_send(root, type_defn)
+            end
+          end
+        end
+      end
 
       NullScalarCoerce = ->(val, _ctx) { val }
 
@@ -48,14 +53,14 @@ module GraphQL
             type_name = type.fetch("name")
             type = types[type_name] || Schema::BUILT_IN_TYPES[type_name]
             if type.nil?
-              raise "Type not found: #{type_name.inspect} among #{types.keys.sort}"
+              GraphQL::Schema::LateBoundType.new(type_name)
             else
-              type.graphql_definition
+              type
             end
           when "LIST"
-            ListType.new(of_type: resolve_type(types, type.fetch("ofType")))
+            Schema::List.new(resolve_type(types, type.fetch("ofType")))
           when "NON_NULL"
-            NonNullType.new(of_type: resolve_type(types, type.fetch("ofType")))
+            Schema::NonNull.new(resolve_type(types, type.fetch("ofType")))
           else
             fail GraphQL::RequiredImplementationMissingError, "#{kind} not implemented"
           end
@@ -83,109 +88,111 @@ module GraphQL
         end
 
         def define_type(type, type_resolver)
+          loader = self
           case type.fetch("kind")
           when "ENUM"
-            EnumType.define(
-              name: type["name"],
-              description: type["description"],
-              values: type["enumValues"].map { |enum|
-                EnumType::EnumValue.define(
-                  name: enum["name"],
-                  description: enum["description"],
-                  deprecation_reason: enum["deprecationReason"],
-                  value: enum["name"]
+            Class.new(GraphQL::Schema::Enum) do
+              graphql_name(type["name"])
+              description(type["description"])
+              type["enumValues"].each do |enum_value|
+                value(
+                  enum_value["name"],
+                  description: enum_value["description"],
+                  deprecation_reason: enum_value["deprecation_reason"],
                 )
-              })
+              end
+            end
           when "INTERFACE"
-            InterfaceType.define(
-              name: type["name"],
-              description: type["description"],
-              fields: Hash[(type["fields"] || []).map { |field|
-                [field["name"], define_type(field.merge("kind" => "FIELD"), type_resolver)]
-              }]
-            )
+            Module.new do
+              include GraphQL::Schema::Interface
+              graphql_name(type["name"])
+              description(type["description"])
+              loader.build_fields(self, type["fields"] || [], type_resolver)
+            end
           when "INPUT_OBJECT"
-            InputObjectType.define(
-              name: type["name"],
-              description: type["description"],
-              arguments: Hash[type["inputFields"].map { |arg|
-                [arg["name"], define_type(arg.merge("kind" => "ARGUMENT"), type_resolver)]
-              }]
-            )
-          when "OBJECT"
-            ObjectType.define(
-              name: type["name"],
-              description: type["description"],
-              interfaces: (type["interfaces"] || []).map { |interface|
-                type_resolver.call(interface)
-              },
-              fields: Hash[type["fields"].map { |field|
-                [field["name"], define_type(field.merge("kind" => "FIELD"), type_resolver)]
-              }]
-            )
-          when "FIELD"
-            defns = {
-              name: type["name"],
-              type: type_resolver.call(type["type"]),
-              description: type["description"],
-            }
-
-            # Avoid passing an empty hash, which warns on Ruby 2.7
-            if type["args"].any?
-              defns[:arguments] = Hash[type["args"].map { |arg|
-                [arg["name"], define_type(arg.merge("kind" => "ARGUMENT"), type_resolver)]
-              }]
+            Class.new(GraphQL::Schema::InputObject) do
+              graphql_name(type["name"])
+              description(type["description"])
+              loader.build_arguments(self, type["inputFields"], type_resolver)
             end
-
-            GraphQL::Field.define(**defns)
-          when "ARGUMENT"
-            kwargs = {}
-            if type["defaultValue"]
-              kwargs[:default_value] = begin
-                default_value_str = type["defaultValue"]
-
-                dummy_query_str = "query getStuff($var: InputObj = #{default_value_str}) { __typename }"
-
-                # Returns a `GraphQL::Language::Nodes::Document`:
-                dummy_query_ast = GraphQL.parse(dummy_query_str)
-
-                # Reach into the AST for the default value:
-                input_value_ast = dummy_query_ast.definitions.first.variables.first.default_value
-
-                extract_default_value(default_value_str, input_value_ast)
+          when "OBJECT"
+            Class.new(GraphQL::Schema::Object) do
+              graphql_name(type["name"])
+              description(type["description"])
+              if type["interfaces"]
+                type["interfaces"].each do |interface_type|
+                  implements(type_resolver.call(interface_type))
+                end
               end
+              loader.build_fields(self, type["fields"], type_resolver)
             end
-
-            GraphQL::Argument.define(
-              name: type["name"],
-              type: type_resolver.call(type["type"]),
-              description: type["description"],
-              method_access: false,
-              **kwargs
-            )
           when "SCALAR"
             type_name = type.fetch("name")
-            if GraphQL::Schema::BUILT_IN_TYPES[type_name]
-              GraphQL::Schema::BUILT_IN_TYPES[type_name]
+            if (builtin = GraphQL::Schema::BUILT_IN_TYPES[type_name])
+              builtin
             else
-              ScalarType.define(
-                name: type["name"],
-                description: type["description"],
-                coerce: NullScalarCoerce,
-              )
+              Class.new(GraphQL::Schema::Scalar) do
+                graphql_name(type["name"])
+                description(type["description"])
+              end
             end
           when "UNION"
-            UnionType.define(
-              name: type["name"],
-              description: type["description"],
-              possible_types: type["possibleTypes"].map { |possible_type|
-                type_resolver.call(possible_type)
-              }
-            )
+            Class.new(GraphQL::Schema::Union) do
+              graphql_name(type["name"])
+              description(type["description"])
+              possible_types(*(type["possibleTypes"].map { |pt| type_resolver.call(pt) }))
+            end
           else
             fail GraphQL::RequiredImplementationMissingError, "#{type["kind"]} not implemented"
           end
         end
+
+        public
+
+        def build_fields(type_defn, fields, type_resolver)
+          loader = self
+          fields.each do |field_hash|
+            type_defn.field(
+              field_hash["name"],
+              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)
+              end
+            end
+          end
+        end
+
+        def build_arguments(arg_owner, args, type_resolver)
+          args.each do |arg|
+            kwargs = {
+              type: type_resolver.call(arg["type"]),
+              description: arg["description"],
+              required: false,
+              method_access: false,
+              camelize: false,
+            }
+
+            if arg["defaultValue"]
+              default_value_str = arg["defaultValue"]
+
+              dummy_query_str = "query getStuff($var: InputObj = #{default_value_str}) { __typename }"
+
+              # Returns a `GraphQL::Language::Nodes::Document`:
+              dummy_query_ast = GraphQL.parse(dummy_query_str)
+
+              # Reach into the AST for the default value:
+              input_value_ast = dummy_query_ast.definitions.first.variables.first.default_value
+
+              kwargs[:default_value] = extract_default_value(default_value_str, input_value_ast)
+            end
+
+            arg_owner.argument(arg["name"], **kwargs)
+          end
+        end
       end
     end
   end

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

@@ -63,10 +63,12 @@ module GraphQL
           self.class.argument_class(new_arg_class)
         end
 
+        # @api private
         # @param values [Hash<String, Object>]
         # @param context [GraphQL::Query::Context]
-        # @return Hash<Symbol, Object>
+        # @return [Hash<Symbol, Object>, Execution::Lazy<Hash>]
         def coerce_arguments(parent_object, values, context)
+          argument_values = {}
           kwarg_arguments = {}
           # Cache this hash to avoid re-merging it
           arg_defns = self.arguments
@@ -75,6 +77,7 @@ module GraphQL
           arg_lazies = arg_defns.map do |arg_name, arg_defn|
             arg_key = arg_defn.keyword
             has_value = false
+            default_used = false
             if values.key?(arg_name)
               has_value = true
               value = values[arg_name]
@@ -84,6 +87,7 @@ module GraphQL
             elsif arg_defn.default_value?
               has_value = true
               value = arg_defn.default_value
+              default_used = true
             end
 
             if has_value
@@ -91,36 +95,52 @@ module GraphQL
               loaded_value = nil
               if loads && !arg_defn.from_resolver?
                 loaded_value = if arg_defn.type.list?
-                  value.map { |val| load_application_object(arg_defn, loads, val, context) }
+                  loaded_values = value.map { |val| load_application_object(arg_defn, loads, val, context) }
+                  context.schema.after_any_lazies(loaded_values) { |result| result }
                 else
                   load_application_object(arg_defn, loads, value, context)
                 end
               end
 
-              context.schema.after_lazy(loaded_value) do |loaded_value|
-                coerced_value = nil
-                prepared_value = context.schema.error_handler.with_error_handling(context) do
-
-                  coerced_value = if loaded_value
-                    loaded_value
-                  else
-                    arg_defn.type.coerce_input(value, context)
-                  end
+              coerced_value = if loaded_value
+                loaded_value
+              else
+                context.schema.error_handler.with_error_handling(context) do
+                  arg_defn.type.coerce_input(value, context)
+                end
+              end
 
+              context.schema.after_lazy(coerced_value) do |coerced_value|
+                prepared_value = context.schema.error_handler.with_error_handling(context) do
                   arg_defn.prepare_value(parent_object, coerced_value, context: context)
                 end
 
-                kwarg_arguments[arg_defn.keyword] = prepared_value
+                kwarg_arguments[arg_key] = prepared_value
+                # TODO code smell to access such a deeply-nested constant in a distant module
+                argument_values[arg_key] = GraphQL::Execution::Interpreter::ArgumentValue.new(
+                  value: prepared_value,
+                  definition: arg_defn,
+                  default_used: default_used,
+                )
               end
             end
           end
 
           maybe_lazies.concat(arg_lazies)
           context.schema.after_any_lazies(maybe_lazies) do
-            kwarg_arguments
+            GraphQL::Execution::Interpreter::Arguments.new(
+              keyword_arguments: kwarg_arguments,
+              argument_values: argument_values,
+            )
           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/non_null.rb

@@ -57,6 +57,11 @@ module GraphQL
       def coerce_result(value, ctx)
         of_type.coerce_result(value, ctx)
       end
+
+      # This is for implementing introspection
+      def description
+        nil
+      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|
@@ -79,14 +86,14 @@ module GraphQL
                 raise "#{int} cannot be implemented since it's not a GraphQL Interface. Use `include` for plain Ruby modules."
               end
 
-              new_memberships << int.type_membership_class.new(int, self, options)
+              new_memberships << int.type_membership_class.new(int, self, **options)
 
               # Include the methods here,
               # `.fields` will use the inheritance chain
               # to find inherited fields
               include(int)
             elsif int.is_a?(GraphQL::InterfaceType)
-              new_memberships << int.type_membership_class.new(int, self, options)
+              new_memberships << int.type_membership_class.new(int, self, **options)
             elsif int.is_a?(String) || int.is_a?(GraphQL::Schema::LateBoundType)
               if options.any?
                 raise ArgumentError, "`implements(...)` doesn't support options with late-loaded types yet. Remove #{options} and open an issue to request this feature."
@@ -162,7 +169,7 @@ module GraphQL
           obj_type = GraphQL::ObjectType.new
           obj_type.name = graphql_name
           obj_type.description = description
-          obj_type.structural_interface_type_memberships = own_interface_type_memberships
+          obj_type.structural_interface_type_memberships = interface_type_memberships
           obj_type.introspection = introspection
           obj_type.mutation = mutation
           obj_type.ast_node = ast_node