graphql 1.10.2 → 1.10.3

data/lib/graphql/query/null_context.rb

@@ -23,6 +23,10 @@ module GraphQL
 
       def [](key); end
 
+      def interpreter?
+        false
+      end
+
       class << self
         extend Forwardable
 
@@ -32,7 +36,7 @@ module GraphQL
           @instance = self.new
         end
 
-        def_delegators :instance, :query, :schema, :warden
+        def_delegators :instance, :query, :schema, :warden, :interpreter?
       end
     end
   end

data/lib/graphql/query/variables.rb

@@ -34,7 +34,9 @@ module GraphQL
               if validation_result.valid?
                 if value_was_provided
                   # Add the variable if a value was provided
-                  memo[variable_name] = if provided_value.nil?
+                  memo[variable_name] = if ctx.interpreter?
+                    provided_value
+                  elsif provided_value.nil?
                     nil
                   else
                     schema.error_handler.with_error_handling(context) do
@@ -42,8 +44,12 @@ module GraphQL
                     end
                   end
                 elsif default_value != nil
-                  # Add the variable if it wasn't provided but it has a default value (including `null`)
-                  memo[variable_name] = GraphQL::Query::LiteralInput.coerce(variable_type, default_value, self)
+                  memo[variable_name] = if ctx.interpreter?
+                    default_value
+                  else
+                    # Add the variable if it wasn't provided but it has a default value (including `null`)
+                    GraphQL::Query::LiteralInput.coerce(variable_type, default_value, self)
+                  end
                 end
               end
             rescue GraphQL::CoercionError, GraphQL::ExecutionError => ex

data/lib/graphql/schema.rb

@@ -787,7 +787,7 @@ module GraphQL
       def_delegators :graphql_definition,
         # Execution
         :execution_strategy_for_operation,
-        :validate, :multiplex_analyzers,
+        :validate,
         # Configuration
         :metadata, :redefine,
         :id_from_object_proc, :object_from_id_proc,
@@ -942,8 +942,24 @@ module GraphQL
           find_inherited_value(:types, EMPTY_HASH)[type_name]
       end
 
+      # @api private
+      attr_writer :connections
+
       # @return [GraphQL::Pagination::Connections] if installed
-      attr_accessor :connections
+      def connections
+        if defined?(@connections)
+          @connections
+        else
+          inherited_connections = find_inherited_value(:connections, nil)
+          # This schema is part of an inheritance chain which is using new connections,
+          # make a new instance, so we don't pollute the upstream one.
+          if inherited_connections
+            @connections = Pagination::Connections.new(schema: self)
+          else
+            nil
+          end
+        end
+      end
 
       def new_connections?
         !!connections

data/lib/graphql/schema/build_from_definition.rb

@@ -42,7 +42,6 @@ module GraphQL
           end
           schema_definition = schema_defns.first
           types = {}
-          types.merge!(GraphQL::Schema::BUILT_IN_TYPES)
           directives = {}
           type_resolver = ->(type) { resolve_type(types, type)  }
 
@@ -69,6 +68,21 @@ module GraphQL
             end
           end
 
+          # At this point, if types named by the built in types are _late-bound_ types,
+          # that means they were referenced in the schema but not defined in the schema.
+          # That's supported for built-in types. (Eg, you can use `String` without defining it.)
+          # In that case, insert the concrete type definition now.
+          #
+          # However, if the type in `types` is a _concrete_ type definition, that means that
+          # the document contained an explicit definition of the scalar type.
+          # Don't override it in this case.
+          GraphQL::Schema::BUILT_IN_TYPES.each do |scalar_name, built_in_scalar|
+            existing_type = types[scalar_name]
+            if existing_type.is_a?(GraphQL::Schema::LateBoundType)
+              types[scalar_name] = built_in_scalar
+            end
+          end
+
           directives = GraphQL::Schema.default_directives.merge(directives)
 
           if schema_definition

data/lib/graphql/schema/enum.rb

@@ -63,8 +63,11 @@ module GraphQL
         def enum_value_class(new_enum_value_class = nil)
           if new_enum_value_class
             @enum_value_class = new_enum_value_class
+          elsif defined?(@enum_value_class) && @enum_value_class
+            @enum_value_class
+          else
+            superclass <= GraphQL::Schema::Enum ? superclass.enum_value_class : nil
           end
-          @enum_value_class || (superclass <= GraphQL::Schema::Enum ? superclass.enum_value_class : nil)
         end
 
         def kind

data/lib/graphql/schema/field.rb

@@ -648,6 +648,17 @@ module GraphQL
           # Apply any `prepare` methods. Not great code organization, can this go somewhere better?
           arguments.each do |name, arg_defn|
             ruby_kwargs_key = arg_defn.keyword
+
+            loads = arg_defn.loads
+            if ruby_kwargs.key?(ruby_kwargs_key) && loads && !arg_defn.from_resolver?
+              value = ruby_kwargs[ruby_kwargs_key]
+              ruby_kwargs[ruby_kwargs_key] = if arg_defn.type.list?
+                value.map { |val| load_application_object(arg_defn, loads, val, field_ctx.query.context) }
+              else
+                load_application_object(arg_defn, loads, value, field_ctx.query.context)
+              end
+            end
+
             if ruby_kwargs.key?(ruby_kwargs_key) && arg_defn.prepare
               ruby_kwargs[ruby_kwargs_key] = arg_defn.prepare_value(obj, ruby_kwargs[ruby_kwargs_key])
             end

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

@@ -38,7 +38,8 @@ module GraphQL
             value.max_page_size ||= field.max_page_size
             value
           elsif context.schema.new_connections?
-            context.schema.connections.wrap(field, value, arguments, context)
+            wrappers = context.namespace(:connections)[:all_wrappers] ||= context.schema.connections.all_wrappers
+            context.schema.connections.wrap(field, value, arguments, context, wrappers: wrappers)
           else
             if object.is_a?(GraphQL::Schema::Object)
               object = object.object

data/lib/graphql/schema/input_object.rb

@@ -5,6 +5,7 @@ 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
 
       include GraphQL::Dig
@@ -23,19 +24,25 @@ module GraphQL
         self.class.arguments.each do |name, arg_defn|
           @arguments_by_keyword[arg_defn.keyword] = arg_defn
           ruby_kwargs_key = arg_defn.keyword
-          loads = arg_defn.loads
-
-          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?
-              value.map { |val| load_application_object(arg_defn, loads, val) }
-            else
-              load_application_object(arg_defn, loads, value)
+
+          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]
+              @ruby_style_hash[ruby_kwargs_key] = 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
             end
-          end
 
-          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])
+            # 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?
+              @ruby_style_hash[ruby_kwargs_key] = arg_defn.prepare_value(self, @ruby_style_hash[ruby_kwargs_key])
+            end
           end
         end
       end
@@ -169,7 +176,7 @@ module GraphQL
           # 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])
+              result.add_problem("Field is not defined on #{self.graphql_name}", [name])
             end
           end
 
@@ -188,32 +195,8 @@ module GraphQL
           if value.nil?
             return nil
           end
-          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 = coerce_arguments(nil, value, ctx)
 
           input_obj_instance = self.new(ruby_kwargs: input_values, context: ctx, defaults_used: nil)
           input_obj_instance.prepare

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

@@ -26,7 +26,7 @@ module GraphQL
         end
 
         def overridden_graphql_name
-          @graphql_name
+          defined?(@graphql_name) ? @graphql_name : nil
         end
 
         # Just a convenience method to point out that people should use graphql_name instead
@@ -46,8 +46,10 @@ module GraphQL
         def description(new_description = nil)
           if new_description
             @description = new_description
-          else
+          elsif defined?(@description)
             @description
+          else
+            nil
           end
         end
 
@@ -68,8 +70,10 @@ module GraphQL
         def introspection(new_introspection = nil)
           if !new_introspection.nil?
             @introspection = new_introspection
-          else
+          elsif defined?(@introspection)
             @introspection
+          else
+            false
           end
         end
 
@@ -82,8 +86,11 @@ module GraphQL
         def mutation(mutation_class = nil)
           if mutation_class
             @mutation = mutation_class
+          elsif defined?(@mutation)
+            @mutation
+          else
+            nil
           end
-          @mutation
         end
 
         # @return [GraphQL::BaseType] Convert this type to a legacy-style object.

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

@@ -63,12 +63,63 @@ module GraphQL
           self.class.argument_class(new_arg_class)
         end
 
+        # @param values [Hash<String, Object>]
+        # @param context [GraphQL::Query::Context]
+        # @return Hash<Symbol, Object>
+        def coerce_arguments(parent_object, values, context)
+          kwarg_arguments = {}
+          # Cache this hash to avoid re-merging it
+          arg_defns = self.arguments
+
+          arg_defns.each do |arg_name, arg_defn|
+            arg_key = arg_defn.keyword
+            has_value = false
+            if values.key?(arg_name)
+              has_value = true
+              value = values[arg_name]
+            elsif values.key?(arg_key)
+              has_value = true
+              value = values[arg_key]
+            elsif arg_defn.default_value?
+              has_value = true
+              value = arg_defn.default_value
+            end
+
+            if has_value
+              loads = arg_defn.loads
+              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) }
+                else
+                  load_application_object(arg_defn, loads, value, context)
+                end
+              end
+
+              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
+
+                arg_defn.prepare_value(parent_object, coerced_value, context: context)
+              end
+              kwarg_arguments[arg_defn.keyword] = prepared_value
+            end
+          end
+          kwarg_arguments
+        end
+
         module ArgumentClassAccessor
           def argument_class(new_arg_class = nil)
             if new_arg_class
               @argument_class = new_arg_class
+            elsif defined?(@argument_class) && @argument_class
+              @argument_class
             else
-              @argument_class || (superclass.respond_to?(:argument_class) ? superclass.argument_class : GraphQL::Schema::Argument)
+              superclass.respond_to?(:argument_class) ? superclass.argument_class : GraphQL::Schema::Argument
             end
           end
         end
@@ -85,7 +136,7 @@ module GraphQL
             context.schema.object_from_id(id, context)
           end
 
-          def load_application_object(argument, lookup_as_type, id)
+          def load_application_object(argument, lookup_as_type, id, context)
             # See if any object can be found for this ID
             loaded_application_object = object_from_id(lookup_as_type, id, context)
             context.schema.after_lazy(loaded_application_object) do |application_object|

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

@@ -8,8 +8,11 @@ module GraphQL
         def ast_node(new_ast_node = nil)
           if new_ast_node
             @ast_node = new_ast_node
+          elsif defined?(@ast_node)
+            @ast_node
+          else
+            nil
           end
-          @ast_node
         end
       end
     end

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

@@ -70,7 +70,7 @@ module GraphQL
         def field_class(new_field_class = nil)
           if new_field_class
             @field_class = new_field_class
-          elsif @field_class
+          elsif defined?(@field_class) && @field_class
             @field_class
           elsif self.is_a?(Class)
             superclass.respond_to?(:field_class) ? superclass.field_class : GraphQL::Schema::Field

data/lib/graphql/schema/resolver.rb

@@ -285,7 +285,7 @@ module GraphQL
               argument = @arguments_by_keyword[:#{arg_defn.keyword}]
               lookup_as_type = @arguments_loads_as_type[:#{arg_defn.keyword}]
               context.schema.after_lazy(values) do |values2|
-                GraphQL::Execution::Lazy.all(values2.map { |value| load_application_object(argument, lookup_as_type, value) })
+                GraphQL::Execution::Lazy.all(values2.map { |value| load_application_object(argument, lookup_as_type, value, context) })
               end
             end
             RUBY
@@ -294,7 +294,7 @@ module GraphQL
             def load_#{arg_defn.keyword}(value)
               argument = @arguments_by_keyword[:#{arg_defn.keyword}]
               lookup_as_type = @arguments_loads_as_type[:#{arg_defn.keyword}]
-              load_application_object(argument, lookup_as_type, value)
+              load_application_object(argument, lookup_as_type, value, context)
             end
             RUBY
           else

data/lib/graphql/schema/resolver/has_payload_type.rb

@@ -26,8 +26,10 @@ module GraphQL
         def field_class(new_class = nil)
           if new_class
             @field_class = new_class
+          elsif defined?(@field_class) && @field_class
+            @field_class
           else
-            @field_class || find_inherited_value(:field_class, GraphQL::Schema::Field)
+            find_inherited_value(:field_class, GraphQL::Schema::Field)
           end
         end
 

data/lib/graphql/schema/warden.rb

@@ -230,6 +230,16 @@ module GraphQL
           unvisited_types << root_type if root_type
         end
         unvisited_types.concat(@schema.introspection_system.types.values)
+
+        directives.each do |dir_class|
+          dir_class.arguments.values.each do |arg_defn|
+            arg_t = arg_defn.type.unwrap
+            if get_type(arg_t.graphql_name)
+              unvisited_types << arg_t
+            end
+          end
+        end
+
         @schema.orphan_types.each do |orphan_type|
           if get_type(orphan_type.graphql_name)
             unvisited_types << orphan_type

data/lib/graphql/static_validation/rules/variable_default_values_are_correctly_typed.rb

@@ -27,7 +27,6 @@ module GraphQL
 
               if !valid
                 error_message ||= "Default value for $#{node.name} doesn't match type #{type.to_type_signature}"
-                VariableDefaultValuesAreCorrectlyTypedError
                 add_error(GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTypedError.new(
                   error_message,
                   nodes: node,

data/lib/graphql/subscriptions.rb

@@ -88,6 +88,10 @@ module GraphQL
     def execute(subscription_id, event, object)
       # Lookup the saved data for this subscription
       query_data = read_subscription(subscription_id)
+      if query_data.nil?
+        # Jump down to the `delete_subscription` call
+        raise GraphQL::Schema::Subscription::UnsubscribedError
+      end
       # Fetch the required keys from the saved data
       query_string = query_data.fetch(:query_string)
       variables = query_data.fetch(:variables)
@@ -95,14 +99,12 @@ module GraphQL
       operation_name = query_data.fetch(:operation_name)
       # Re-evaluate the saved query
       result = @schema.execute(
-        **{
-          query: query_string,
-          context: context,
-          subscription_topic: event.topic,
-          operation_name: operation_name,
-          variables: variables,
-          root_value: object,
-        }
+        query: query_string,
+        context: context,
+        subscription_topic: event.topic,
+        operation_name: operation_name,
+        variables: variables,
+        root_value: object,
       )
       deliver(subscription_id, result)
     rescue GraphQL::Schema::Subscription::NoUpdateError
@@ -226,7 +228,10 @@ module GraphQL
         # match query arguments.
         arg_owner.arguments.each do |name, arg_defn|
           if arg_defn.default_value? && !normalized_args.key?(arg_defn.name)
-            normalized_args[arg_defn.name] = arg_defn.default_value
+            default_value = arg_defn.default_value
+            # We don't have an underlying "object" here, so it can't call methods.
+            # This is broken.
+            normalized_args[arg_defn.name] = arg_defn.prepare_value(nil, default_value, context: GraphQL::Query::NullContext)
           end
         end