graphql 1.5.5 → 1.5.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ef472807dc31f5d5bc215491e5c4a512d853b517
-  data.tar.gz: 151d4556ac7c07a270e37e40a71616dfad89129b
+  metadata.gz: 8fd00bd7b6d3c884c97818e792423683197e2f45
+  data.tar.gz: 731475b235eb76d4ea0e574e734d8adba1188c96
 SHA512:
-  metadata.gz: 825fdd6d9aac63cf8904e1a52be462499286063ccab8799497affabf52d1a0b8b2afe090e5fef84a564c087803ca4b4b38d4dc7fa898e145047e749aa1d0e12c
-  data.tar.gz: 43c0d734ac9014bd7df9f9e26e70052e62f2ae0d7a84b59642622e2786ffd806fbc076638411ce4621b2dd355c7479ac05c7e9fed8993701126611c8ebe428d6
+  metadata.gz: 54fc7fd2ac112ba5be3d405d256dfe81d3dfa58c688820f406fbe97671245b7395076484915b1c67cb074a948304c015af52f5888fa1670eee88bc68f7dab779
+  data.tar.gz: d4fc22d899a6ea6fd5bbd3895c0f5c5837956a3264b0badbfc6f09237a07ac02fa489b3f114f62c3247067157a4e85051f48cee4d301be89d5792d48893d2af2

data/lib/graphql.rb

@@ -82,12 +82,11 @@ require "graphql/schema"
 require "graphql/schema/loader"
 require "graphql/schema/printer"
 
-# Order does not matter for these:
-
 require "graphql/analysis_error"
 require "graphql/runtime_type_error"
 require "graphql/invalid_null_error"
 require "graphql/unresolved_type_error"
+require "graphql/string_encoding_error"
 require "graphql/query"
 require "graphql/internal_representation"
 require "graphql/static_validation"

data/lib/graphql/analysis/query_complexity.rb

@@ -53,7 +53,6 @@ module GraphQL
       # Get a complexity value for a field,
       # by getting the number or calling its proc
       def get_complexity(irep_node, query, child_complexity)
-        type_defn = irep_node.owner_type
         field_defn = irep_node.definition
         defined_complexity = field_defn.complexity
         case defined_complexity

data/lib/graphql/argument.rb

@@ -14,13 +14,40 @@ module GraphQL
   #   GraphQL::InputObjectType.define do
   #     argument :newName, !types.String
   #   end
+  #
+  # @example defining an argument with a `prepare` function
+  #   GraphQL::Field.define do
+  #     argument :userId, types.ID, prepare: ->(userId) do
+  #       User.find_by(id: userId)
+  #     end
+  #   end
+  #
+  # @example returning an {ExecutionError} from a `prepare` function
+  #   GraphQL::Field.define do
+  #     argument :date do
+  #       type !types.String
+  #       prepare ->(date) do
+  #         return GraphQL::ExecutionError.new("Invalid date format") unless DateValidator.valid?(date)
+  #         Time.zone.parse(date)
+  #       end
+  #     end
+  #   end
 
   class Argument
     include GraphQL::Define::InstanceDefinable
-    accepts_definitions :name, :type, :description, :default_value, :as
+    accepts_definitions :name, :type, :description, :default_value, :as, :prepare
     attr_accessor :type, :description, :default_value, :name, :as
 
-    ensure_defined(:name, :description, :default_value, :type=, :type, :as, :expose_as)
+    ensure_defined(:name, :description, :default_value, :type=, :type, :as, :expose_as, :prepare)
+
+    # @api private
+    module DefaultPrepare
+      def self.call(value); value; end
+    end
+
+    def initialize
+      @prepare_proc = DefaultPrepare
+    end
 
     def initialize_copy(other)
       @expose_as = nil
@@ -54,9 +81,21 @@ module GraphQL
       @expose_as ||= (@as || @name).to_s
     end
 
+    # @param value
+    # @return [Object] The prepared `value` for this argument or `value` itself if no `prepare` function exists.
+    def prepare(value)
+      @prepare_proc.call(value)
+    end
+
+    # Assign a `prepare` function to prepare this argument's value before `resolve` functions are called.
+    # @param prepare_proc [Proc]
+    def prepare=(prepare_proc)
+      @prepare_proc = prepare_proc
+    end
+
     NO_DEFAULT_VALUE = Object.new
     # @api private
-    def self.from_dsl(name, type = nil, description = nil, default_value: NO_DEFAULT_VALUE, as: nil, &block)
+    def self.from_dsl(name, type = nil, description = nil, default_value: NO_DEFAULT_VALUE, as: nil, prepare: DefaultPrepare, &block)
       argument = if block_given?
         GraphQL::Argument.define(&block)
       else
@@ -70,6 +109,7 @@ module GraphQL
         argument.default_value = default_value
       end
       argument.as = as
+      argument.prepare = prepare
 
 
       argument

data/lib/graphql/base_type.rb

@@ -97,21 +97,58 @@ module GraphQL
 
     alias :inspect :to_s
 
-    def valid_input?(value, warden)
-      validate_input(value, warden).valid?
+    def valid_isolated_input?(value)
+      valid_input?(value, GraphQL::Query::NullContext)
     end
 
-    def validate_input(value, warden)
+    def validate_isolated_input(value)
+      validate_input(value, GraphQL::Query::NullContext)
+    end
+
+    def coerce_isolated_input(value)
+      coerce_input(value, GraphQL::Query::NullContext)
+    end
+
+    def coerce_isolated_result(value)
+      coerce_result(value, GraphQL::Query::NullContext)
+    end
+
+    def valid_input?(value, ctx = nil)
+      if ctx.nil?
+        warn_deprecated_coerce("valid_isolated_input?")
+        ctx = GraphQL::Query::NullContext
+      end
+
+      validate_input(value, ctx).valid?
+    end
+
+    def validate_input(value, ctx = nil)
+      if ctx.nil?
+        warn_deprecated_coerce("validate_isolated_input")
+        ctx = GraphQL::Query::NullContext
+      end
+
       if value.nil?
         GraphQL::Query::InputValidationResult.new
       else
-        validate_non_null_input(value, warden)
+        validate_non_null_input(value, ctx)
+      end
+    end
+
+    def coerce_input(value, ctx = nil)
+      if value.nil?
+        nil
+      else
+        if ctx.nil?
+          warn_deprecated_coerce("coerce_isolated_input")
+          ctx = GraphQL::Query::NullContext
+        end
+        coerce_non_null_input(value, ctx)
       end
     end
 
-    def coerce_input(value)
-      return nil if value.nil?
-      coerce_non_null_input(value)
+    def coerce_result(value, ctx)
+      raise NotImplementedError
     end
 
     # Types with fields may override this
@@ -168,5 +205,11 @@ module GraphQL
       printer ||= GraphQL::Schema::Printer.new(schema, **args)
       printer.print_type(self)
     end
+
+    private
+
+    def warn_deprecated_coerce(alt_method_name)
+      warn("Coercing without a context is deprecated; use `#{alt_method_name}` if you don't want context-awareness")
+    end
   end
 end

data/lib/graphql/boolean_type.rb

@@ -3,7 +3,7 @@ GraphQL::BOOLEAN_TYPE = GraphQL::ScalarType.define do
   name "Boolean"
   description "Represents `true` or `false` values."
 
-  coerce_input ->(value) { (value == true || value == false) ? value : nil }
-  coerce_result ->(value) { !!value }
+  coerce_input ->(value, _ctx) { (value == true || value == false) ? value : nil }
+  coerce_result ->(value, _ctx) { !!value }
   default_scalar true
 end

data/lib/graphql/compatibility/execution_specification.rb

@@ -334,7 +334,7 @@ module GraphQL
                 __typename
               }
             }|
-            res = execute_query(query_string, context: {middleware_log: log})
+            execute_query(query_string, context: {middleware_log: log})
             assert_equal ["node", "__typename"], log
           end
 

data/lib/graphql/compatibility/execution_specification/specification_schema.rb

@@ -61,8 +61,8 @@ module GraphQL
 
           timestamp_type = GraphQL::ScalarType.define do
             name "Timestamp"
-            coerce_input ->(value) { Time.at(value.to_i) }
-            coerce_result ->(value) { value.to_i }
+            coerce_input ->(value, _ctx) { Time.at(value.to_i) }
+            coerce_result ->(value, _ctx) { value.to_i }
           end
 
           named_entity_interface_type = GraphQL::InterfaceType.define do

data/lib/graphql/compatibility/lazy_execution_specification.rb

@@ -162,7 +162,7 @@ module GraphQL
             |
 
             log = []
-            res = self.class.lazy_schema.execute(query_str, context: {lazy_instrumentation: log, pushes: []})
+            self.class.lazy_schema.execute(query_str, context: {lazy_instrumentation: log, pushes: []})
             expected_log = [
               "PUSH",
               "Query.push: 1",

data/lib/graphql/enum_type.rb

@@ -105,35 +105,13 @@ module GraphQL
       GraphQL::TypeKinds::ENUM
     end
 
-    def validate_non_null_input(value_name, warden)
-      result = GraphQL::Query::InputValidationResult.new
-      allowed_values = warden.enum_values(self)
-      matching_value = allowed_values.find { |v| v.name == value_name }
-
-      if matching_value.nil?
-        result.add_problem("Expected #{GraphQL::Language.serialize(value_name)} to be one of: #{allowed_values.map(&:name).join(', ')}")
+    def coerce_result(value, ctx = nil)
+      if ctx.nil?
+        warn_deprecated_coerce("coerce_isolated_result")
+        ctx = GraphQL::Query::NullContext
       end
 
-      result
-    end
-
-    # Get the underlying value for this enum value
-    #
-    # @example get episode value from Enum
-    #   episode = EpisodeEnum.coerce("NEWHOPE")
-    #   episode # => 6
-    #
-    # @param value_name [String] the string representation of this enum value
-    # @return [Object] the underlying value for this enum value
-    def coerce_non_null_input(value_name)
-      if @values_by_name.key?(value_name)
-        @values_by_name.fetch(value_name).value
-      else
-        nil
-      end
-    end
-
-    def coerce_result(value, warden = nil)
+      warden = ctx.warden
       all_values = warden ? warden.enum_values(self) : @values_by_name.each_value
       enum_value = all_values.find { |val| val.value == value }
       if enum_value
@@ -160,5 +138,35 @@ module GraphQL
 
     class UnresolvedValueError < GraphQL::Error
     end
+
+    private
+
+    # Get the underlying value for this enum value
+    #
+    # @example get episode value from Enum
+    #   episode = EpisodeEnum.coerce("NEWHOPE")
+    #   episode # => 6
+    #
+    # @param value_name [String] the string representation of this enum value
+    # @return [Object] the underlying value for this enum value
+    def coerce_non_null_input(value_name, ctx)
+      if @values_by_name.key?(value_name)
+        @values_by_name.fetch(value_name).value
+      else
+        nil
+      end
+    end
+
+    def validate_non_null_input(value_name, ctx)
+      result = GraphQL::Query::InputValidationResult.new
+      allowed_values = ctx.warden.enum_values(self)
+      matching_value = allowed_values.find { |v| v.name == value_name }
+
+      if matching_value.nil?
+        result.add_problem("Expected #{GraphQL::Language.serialize(value_name)} to be one of: #{allowed_values.map(&:name).join(', ')}")
+      end
+
+      result
+    end
   end
 end

data/lib/graphql/execution/execute.rb

@@ -23,8 +23,6 @@ module GraphQL
       private
 
       def resolve_selection(object, current_type, selection, query_ctx, mutation: false )
-        query = query_ctx.query
-
         selection_result = SelectionResult.new
 
         selection.typed_children[current_type].each do |name, subselection|
@@ -143,9 +141,9 @@ module GraphQL
         else
           case field_type.kind
           when GraphQL::TypeKinds::SCALAR
-            field_type.coerce_result(value)
+            field_type.coerce_result(value, field_ctx)
           when GraphQL::TypeKinds::ENUM
-            field_type.coerce_result(value, field_ctx.query.warden)
+            field_type.coerce_result(value, field_ctx)
           when GraphQL::TypeKinds::LIST
             inner_type = field_type.of_type
             i = 0
@@ -174,7 +172,7 @@ module GraphQL
             result
           when GraphQL::TypeKinds::NON_NULL
             wrapped_type = field_type.of_type
-            inner_value = resolve_value(
+            resolve_value(
               owner,
               parent_type,
               field_defn,

data/lib/graphql/execution/lazy/lazy_method_map.rb

@@ -43,7 +43,7 @@ module GraphQL
         private
 
         def find_superclass_method(value_class)
-          @storage.each { |lazy_class, lazy_value_method|
+          @storage.each_pair { |lazy_class, lazy_value_method|
             return lazy_value_method if value_class < lazy_class
           }
           nil
@@ -54,7 +54,7 @@ module GraphQL
           extend Forwardable
           # Technically this should be under the mutex too,
           # but I know it's only used when the lock is already acquired.
-          def_delegators :@storage, :each, :size
+          def_delegators :@storage, :each_pair, :size
 
           def initialize
             @semaphore = Mutex.new

data/lib/graphql/float_type.rb

@@ -3,7 +3,7 @@ GraphQL::FLOAT_TYPE = GraphQL::ScalarType.define do
   name "Float"
   description "Represents signed double-precision fractional values as specified by [IEEE 754](http://en.wikipedia.org/wiki/IEEE_floating_point)."
 
-  coerce_input ->(value) { value.is_a?(Numeric) ? value.to_f : nil }
-  coerce_result ->(value) { value.to_f }
+  coerce_input ->(value, _ctx) { value.is_a?(Numeric) ? value.to_f : nil }
+  coerce_result ->(value, _ctx) { value.to_f }
   default_scalar true
 end

data/lib/graphql/function.rb

@@ -78,6 +78,11 @@ module GraphQL
         end
       end
 
+      # Provides shorthand access to GraphQL's built-in types
+      def types
+        GraphQL::Define::TypeDefiner.instance
+      end
+
       # Get or set the return type for this function class & descendants
       # @return [GraphQL::BaseType]
       def type(premade_type = nil, &block)

data/lib/graphql/id_type.rb

@@ -3,8 +3,8 @@ GraphQL::ID_TYPE = GraphQL::ScalarType.define do
   name "ID"
   description "Represents a unique identifier that is Base64 obfuscated. It is often used to refetch an object or as key for a cache. The ID type appears in a JSON response as a String; however, it is not intended to be human-readable. When expected as an input type, any string (such as `\"VXNlci0xMA==\"`) or integer (such as `4`) input value will be accepted as an ID."
 
-  coerce_result ->(value) { value.to_s }
-  coerce_input ->(value) {
+  coerce_result ->(value, _ctx) { value.to_s }
+  coerce_input ->(value, _ctx) {
     case value
     when String, Integer
       value.to_s

data/lib/graphql/input_object_type.rb

@@ -55,7 +55,51 @@ module GraphQL
       GraphQL::TypeKinds::INPUT_OBJECT
     end
 
-    def validate_non_null_input(input, warden)
+    def coerce_result(value, ctx = nil)
+      if ctx.nil?
+        warn_deprecated_coerce("coerce_isolated_result")
+        ctx = GraphQL::Query::NullContext
+      end
+
+      # 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
+
+    private
+
+    def coerce_non_null_input(value, ctx)
+      input_values = {}
+
+      arguments.each do |input_key, input_field_defn|
+        field_value = value[input_key]
+
+        if value.key?(input_key)
+          input_values[input_key] = input_field_defn.type.coerce_input(field_value, ctx)
+        elsif input_field_defn.default_value?
+          input_values[input_key] = input_field_defn.default_value
+        end
+      end
+
+      GraphQL::Query::Arguments.new(input_values, argument_definitions: arguments)
+    end
+
+    def validate_non_null_input(input, ctx)
+      warden = ctx.warden
       result = GraphQL::Query::InputValidationResult.new
 
       if (input.to_h rescue nil).nil?
@@ -78,7 +122,7 @@ module GraphQL
 
       # Items in the input that are expected, but have invalid values
       visible_arguments_map.map do |name, field|
-        field_result = field.type.validate_input(input[name], warden)
+        field_result = field.type.validate_input(input[name], ctx)
         if !field_result.valid?
           result.merge_result!(name, field_result)
         end
@@ -86,39 +130,5 @@ module GraphQL
 
       result
     end
-
-    def coerce_non_null_input(value)
-      input_values = {}
-
-      arguments.each do |input_key, input_field_defn|
-        field_value = value[input_key]
-
-        if value.key?(input_key)
-          coerced_value = input_field_defn.type.coerce_input(field_value)
-        else
-          coerced_value = input_field_defn.default_value
-        end
-
-        if coerced_value || value.key?(input_key)
-          input_values[input_key] = coerced_value
-        end
-      end
-
-      GraphQL::Query::Arguments.new(input_values, argument_definitions: arguments)
-    end
-
-    def coerce_result(value)
-      # 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]
-        result[input_key] = input_value.nil? ? nil : input_field_defn.type.coerce_result(input_value) if value.key?(input_key)
-      end
-
-      result
-    end
   end
 end