graphql 1.5.5 → 1.5.6

data/lib/graphql/int_type.rb

@@ -3,7 +3,7 @@ GraphQL::INT_TYPE = GraphQL::ScalarType.define do
   name "Int"
   description "Represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1."
 
-  coerce_input ->(value) { value.is_a?(Numeric) ? value.to_i : nil }
-  coerce_result ->(value) { value.to_i }
+  coerce_input ->(value, _ctx) { value.is_a?(Numeric) ? value.to_i : nil }
+  coerce_result ->(value, _ctx) { value.to_i }
   default_scalar true
 end

data/lib/graphql/introspection/input_value_type.rb

@@ -14,7 +14,7 @@ GraphQL::Introspection::InputValueType = GraphQL::ObjectType.define do
         if value.nil?
           'null'
         else
-          coerced_default_value = obj.type.coerce_result(value)
+          coerced_default_value = obj.type.coerce_result(value, ctx)
           if obj.type.unwrap.is_a?(GraphQL::EnumType)
             coerced_default_value
           else

data/lib/graphql/list_type.rb

@@ -40,11 +40,25 @@ module GraphQL
       "[#{of_type.to_s}]"
     end
 
-    def validate_non_null_input(value, warden)
+    def coerce_result(value, ctx = nil)
+      if ctx.nil?
+        warn_deprecated_coerce("coerce_isolated_result")
+        ctx = GraphQL::Query::NullContext
+      end
+      Array(value).map { |item| item.nil? ? nil : of_type.coerce_result(item, ctx) }
+    end
+
+    private
+
+    def coerce_non_null_input(value, ctx)
+      Array(value).map { |item| of_type.coerce_input(item, ctx) }
+    end
+
+    def validate_non_null_input(value, ctx)
       result = GraphQL::Query::InputValidationResult.new
 
-      ensure_array(value).each_with_index do |item, index|
-        item_result = of_type.validate_input(item, warden)
+      Array(value).each_with_index do |item, index|
+        item_result = of_type.validate_input(item, ctx)
         if !item_result.valid?
           result.merge_result!(index, item_result)
         end
@@ -52,19 +66,5 @@ module GraphQL
 
       result
     end
-
-    def coerce_non_null_input(value)
-      ensure_array(value).map { |item| of_type.coerce_input(item) }
-    end
-
-    def coerce_result(value)
-      ensure_array(value).map { |item| item.nil? ? nil : of_type.coerce_result(item) }
-    end
-
-    private
-
-    def ensure_array(value)
-      value.is_a?(Array) ? value : [value]
-    end
   end
 end

data/lib/graphql/non_null_type.rb

@@ -30,6 +30,7 @@ module GraphQL
   #
   class NonNullType < GraphQL::BaseType
     include GraphQL::BaseType::ModifiesAnotherType
+    extend Forwardable
 
     attr_reader :of_type
     def initialize(of_type:)
@@ -37,27 +38,21 @@ module GraphQL
       @of_type = of_type
     end
 
-    def valid_input?(value, warden)
-      validate_input(value, warden).valid?
+    def valid_input?(value, ctx)
+      validate_input(value, ctx).valid?
     end
 
-    def validate_input(value, warden)
+    def validate_input(value, ctx)
       if value.nil?
         result = GraphQL::Query::InputValidationResult.new
         result.add_problem("Expected value to not be null")
         result
       else
-        of_type.validate_input(value, warden)
+        of_type.validate_input(value, ctx)
       end
     end
 
-    def coerce_input(value)
-      of_type.coerce_input(value)
-    end
-
-    def coerce_result(value)
-      of_type.coerce_result(value)
-    end
+    def_delegators :@of_type, :coerce_input, :coerce_result
 
     def kind
       GraphQL::TypeKinds::NON_NULL

data/lib/graphql/query.rb

@@ -4,6 +4,7 @@ require "graphql/query/arguments_cache"
 require "graphql/query/context"
 require "graphql/query/executor"
 require "graphql/query/literal_input"
+require "graphql/query/null_context"
 require "graphql/query/serial_execution"
 require "graphql/query/variables"
 require "graphql/query/input_validation_result"
@@ -145,8 +146,7 @@ module GraphQL
     def variables
       @variables ||= begin
         vars = GraphQL::Query::Variables.new(
-          @schema,
-          @warden,
+          @context,
           @ast_variables,
           @provided_variables,
         )

data/lib/graphql/query/literal_input.rb

@@ -14,9 +14,9 @@ module GraphQL
         else
           case type
           when GraphQL::ScalarType
-            type.coerce_input(ast_node)
+            type.coerce_input(ast_node, variables.context)
           when GraphQL::EnumType
-            type.coerce_input(ast_node.name)
+            type.coerce_input(ast_node.name, variables.context)
           when GraphQL::NonNullType
             LiteralInput.coerce(type.of_type, ast_node, variables)
           when GraphQL::ListType
@@ -49,14 +49,21 @@ module GraphQL
           # First, check the argument in the AST.
           # If the value is a variable,
           # only add a value if the variable is actually present.
-          # Otherwise, coerce the value in the AST and add it.
+          # Otherwise, coerce the value in the AST, prepare the value and add it.
           if ast_arg
-            if ast_arg.value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
-              if variables.key?(ast_arg.value.name)
-                values_hash[ast_arg.name] = coerce(arg_defn.type, ast_arg.value, variables)
+            value_is_a_variable = ast_arg.value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
+
+            if (!value_is_a_variable || (value_is_a_variable && variables.key?(ast_arg.value.name)))
+
+              value = coerce(arg_defn.type, ast_arg.value, variables)
+              value = arg_defn.prepare(value)
+
+              if value.is_a?(GraphQL::ExecutionError)
+                value.ast_node = ast_arg
+                raise value
               end
-            else
-              values_hash[ast_arg.name] = coerce(arg_defn.type, ast_arg.value, variables)
+
+              values_hash[ast_arg.name] = value
             end
           end
 

data/lib/graphql/query/null_context.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module GraphQL
+  class Query
+    # This object can be `ctx` in places where there is no query
+    class NullContext
+      attr_reader :schema, :query, :warden
+
+      def initialize
+        @query = nil
+        @schema = GraphQL::Schema.new
+        @warden = GraphQL::Schema::Warden.new(
+          GraphQL::Schema::NullMask,
+          context: self,
+          schema: @schema,
+        )
+      end
+
+      class << self
+        extend Forwardable
+
+        def instance
+          @instance = self.new
+        end
+
+        def_delegators :instance, :query, :schema, :warden
+      end
+    end
+  end
+end

data/lib/graphql/query/serial_execution/value_resolution.rb

@@ -16,10 +16,8 @@ module GraphQL
             end
           else
             case field_type.kind
-            when GraphQL::TypeKinds::SCALAR
-              field_type.coerce_result(value)
-            when GraphQL::TypeKinds::ENUM
-              field_type.coerce_result(value, query_ctx.query.warden)
+            when GraphQL::TypeKinds::SCALAR, GraphQL::TypeKinds::ENUM
+              field_type.coerce_result(value, query_ctx)
             when GraphQL::TypeKinds::LIST
               wrapped_type = field_type.of_type
               result = []

data/lib/graphql/query/variables.rb

@@ -8,9 +8,11 @@ module GraphQL
       # @return [Array<GraphQL::Query::VariableValidationError>]  Any errors encountered when parsing the provided variables and literal values
       attr_reader :errors
 
-      def initialize(schema, warden, ast_variables, provided_variables)
-        @schema = schema
-        @warden = warden
+      attr_reader :context
+
+      def initialize(ctx, ast_variables, provided_variables)
+        schema = ctx.schema
+        @context = ctx
         @provided_variables = provided_variables
         @errors = []
         @storage = ast_variables.each_with_object({}) do |ast_variable, memo|
@@ -18,7 +20,7 @@ module GraphQL
           # - First, use the value provided at runtime
           # - Then, fall back to the default value from the query string
           # If it's still nil, raise an error if it's required.
-          variable_type = @schema.type_from_ast(ast_variable.type)
+          variable_type = schema.type_from_ast(ast_variable.type)
           if variable_type.nil?
             # Pass -- it will get handled by a validator
           else
@@ -27,16 +29,16 @@ module GraphQL
             provided_value = @provided_variables[variable_name]
             value_was_provided = @provided_variables.key?(variable_name)
 
-            validation_result = variable_type.validate_input(provided_value, @warden)
+            validation_result = variable_type.validate_input(provided_value, ctx)
             if !validation_result.valid?
               # This finds variables that were required but not provided
               @errors << GraphQL::Query::VariableValidationError.new(ast_variable, variable_type, provided_value, validation_result)
             elsif value_was_provided
               # Add the variable if a value was provided
-              memo[variable_name] = variable_type.coerce_input(provided_value)
+              memo[variable_name] = variable_type.coerce_input(provided_value, ctx)
             elsif default_value
               # 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, {})
+              memo[variable_name] = GraphQL::Query::LiteralInput.coerce(variable_type, default_value, self)
             end
           end
         end

data/lib/graphql/relay/mutation.rb

@@ -163,18 +163,17 @@ module GraphQL
       def input_type
         @input_type ||= begin
           relay_mutation = self
-          GraphQL::InputObjectType.define do
+          input_object_type = GraphQL::InputObjectType.define do
             name("#{relay_mutation.name}Input")
             description("Autogenerated input type of #{relay_mutation.name}")
             input_field :clientMutationId, types.String, "A unique identifier for the client performing the mutation."
-            relay_mutation.arguments.each do |input_field_name, field_obj|
-              kwargs = {}
-              kwargs[:default_value] = field_obj.default_value if field_obj.default_value?
-              kwargs[:as] = field_obj.as
-              input_field(input_field_name, field_obj.type, field_obj.description, **kwargs)
-            end
             mutation(relay_mutation)
           end
+          input_fields.each do |name, arg|
+            input_object_type.arguments[name] = arg
+          end
+
+          input_object_type
         end
       end
 

data/lib/graphql/scalar_type.rb

@@ -30,49 +30,84 @@ module GraphQL
   #     name "Time"
   #     description "Time since epoch in seconds"
   #
-  #     coerce_input ->(value) { Time.at(Float(value)) }
-  #     coerce_result ->(value) { value.to_f }
+  #     coerce_input ->(value, ctx) { Time.at(Float(value)) }
+  #     coerce_result ->(value, ctx) { value.to_f }
   #   end
   #
   class ScalarType < GraphQL::BaseType
     accepts_definitions :coerce, :coerce_input, :coerce_result
     ensure_defined :coerce_non_null_input, :coerce_result
 
+    module NoOpCoerce
+      def self.call(val, ctx)
+        val
+      end
+    end
+
+    def initialize
+      super
+      self.coerce = NoOpCoerce
+    end
+
     def coerce=(proc)
       self.coerce_input = proc
       self.coerce_result = proc
     end
 
-    def validate_non_null_input(value, warden)
-      result = Query::InputValidationResult.new
-      if coerce_non_null_input(value).nil?
-        result.add_problem("Could not coerce value #{GraphQL::Language.serialize(value)} to #{name}")
+    def coerce_input=(coerce_input_fn)
+      if !coerce_input_fn.nil?
+        @coerce_input_proc = ensure_two_arg(coerce_input_fn, :coerce_input)
       end
-      result
     end
 
-    def coerce_non_null_input(value)
-      @coerce_input_proc.call(value)
+    def coerce_result(value, ctx = nil)
+      if ctx.nil?
+        warn_deprecated_coerce("coerce_isolated_result")
+        ctx = GraphQL::Query::NullContext
+      end
+      @coerce_result_proc.call(value, ctx)
     end
 
-    def coerce_input=(proc)
-      if !proc.nil?
-        @coerce_input_proc = proc
+    def coerce_result=(coerce_result_fn)
+      if !coerce_result_fn.nil?
+        @coerce_result_proc = ensure_two_arg(coerce_result_fn, :coerce_result)
       end
     end
 
-    def coerce_result(value)
-      @coerce_result_proc ? @coerce_result_proc.call(value) : value
+    def kind
+      GraphQL::TypeKinds::SCALAR
     end
 
-    def coerce_result=(proc)
-      if !proc.nil?
-        @coerce_result_proc = proc
+    private
+
+    def get_arity(callable)
+      case callable
+      when Proc
+        callable.arity
+      else
+        callable.method(:call).arity
       end
     end
 
-    def kind
-      GraphQL::TypeKinds::SCALAR
+    def ensure_two_arg(callable, method_name)
+      if get_arity(callable) == 1
+        warn("Scalar coerce functions receive two values (`val` and `ctx`), one-argument functions are deprecated (see #{name}.#{method_name}).")
+        ->(val, ctx) { callable.call(val) }
+      else
+        callable
+      end
+    end
+
+    def coerce_non_null_input(value, ctx)
+      @coerce_input_proc.call(value, ctx)
+    end
+
+    def validate_non_null_input(value, ctx)
+      result = Query::InputValidationResult.new
+      if coerce_non_null_input(value, ctx).nil?
+        result.add_problem("Could not coerce value #{GraphQL::Language.serialize(value)} to #{name}")
+      end
+      result
     end
   end
 end

data/lib/graphql/schema.rb

@@ -58,6 +58,7 @@ module GraphQL
       :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
       :max_depth, :max_complexity,
       :orphan_types, :resolve_type, :type_error, :parse_error,
+      :raise_definition_error,
       :object_from_id, :id_from_object,
       :default_mask,
       :cursor_encoder,
@@ -74,7 +75,8 @@ module GraphQL
       :max_depth, :max_complexity,
       :orphan_types, :directives,
       :query_analyzers, :instrumenters, :lazy_methods,
-      :cursor_encoder
+      :cursor_encoder,
+      :raise_definition_error
 
     # @return [MiddlewareChain] MiddlewareChain which is applied to fields during execution
     attr_accessor :middleware
@@ -96,6 +98,7 @@ module GraphQL
     attr_reader :static_validator, :object_from_id_proc, :id_from_object_proc, :resolve_type_proc
 
     def initialize
+      @definition_error = nil
       @orphan_types = []
       @directives = DIRECTIVES.reduce({}) { |m, d| m[d.name] = d; m }
       @static_validator = GraphQL::StaticValidation::Validator.new(schema: self)
@@ -175,6 +178,15 @@ module GraphQL
       validation_error = Validation.validate(self)
       validation_error && raise(NotImplementedError, validation_error)
       build_instrumented_field_map
+      @definition_error = nil
+      nil
+    rescue StandardError => err
+      if @raise_definition_error
+        raise
+      else
+        # Raise this error _later_ to avoid messing with Rails constant loading
+        @definition_error = err
+      end
       nil
     end
 
@@ -195,12 +207,16 @@ module GraphQL
       @types ||= build_types_map
     end
 
-    # Execute a query on itself.
-    # See {Query#initialize} for arguments.
+    # Execute a query on itself. Raises an error if the schema definition is invalid.
+    # @see {Query#initialize} for arguments.
     # @return [Hash] query result, ready to be serialized as JSON
     def execute(*args)
-      query_obj = GraphQL::Query.new(self, *args)
-      query_obj.result
+      if @definition_error
+        raise @definition_error
+      else
+        query_obj = GraphQL::Query.new(self, *args)
+        query_obj.result
+      end
     end
 
     # Resolve field named `field_name` for type `parent_type`.