graphql 1.5.9 → 1.5.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0f7fde27f1042e7ab45a94bf130bd0bf6575fdde
-  data.tar.gz: 22ce0c200aafaf86c07305fc576629df0c739edb
+  metadata.gz: 0e87f7a05371764ee8744616a781f61f103f761c
+  data.tar.gz: e8d2eafe80fbe962c1dd5c017201b82b86def0ad
 SHA512:
-  metadata.gz: 4977dac7e103cebfded6ce613df88651bc5f24a977067a432b3609bb0c3d3e8d7ea90bb161401c7de510cac552582c0c7a396945d8980b2af43e2178fca60e32
-  data.tar.gz: a18ad101dbc96bef323c38a2f07e92e1f46a7addbe5dcb0035db6995b4ce399d87acaf3b688b94742f572ee0c4abe20765afc09cfe623a6defc5318466fc9eff
+  metadata.gz: b83d8c335d98f4149a6ce531b6dc61254fc96bbb5fec35beb2c0fece8eb4fff58693cd7bd48fb89511da84d69cfcec5e639b64372add0c8070c5a9c871804af0
+  data.tar.gz: ef672d60a38c0e1b5ec87af598d7ec221e36c6511ed92f72840bb32be813a0d434d9a0580d2e57e18ad8ad48f486f150d36b72399dbba347a4915686148b1c4e

data/lib/graphql/input_object_type.rb

@@ -98,16 +98,27 @@ module GraphQL
       GraphQL::Query::Arguments.new(input_values, argument_definitions: arguments)
     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)
       warden = ctx.warden
       result = GraphQL::Query::InputValidationResult.new
 
-      if (input.to_h rescue nil).nil?
-        result.add_problem(
-          "Expected #{JSON.generate(input, quirks_mode: true)} to be a key, value object " \
-          " responding to `to_h`."
-        )
-        return result
+      # 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
 
 

data/lib/graphql/relay/mutation.rb

@@ -1,4 +1,8 @@
 # frozen_string_literal: true
+require "graphql/relay/mutation/instrumentation"
+require "graphql/relay/mutation/resolve"
+require "graphql/relay/mutation/result"
+
 module GraphQL
   module Relay
     # Define a Relay mutation:
@@ -178,9 +182,7 @@ module GraphQL
       end
 
       def result_class
-        @result_class ||= begin
-          Result.define_subclass(self)
-        end
+        @result_class ||= Result.define_subclass(self)
       end
 
       private
@@ -193,84 +195,6 @@ module GraphQL
           callable.method(:call).arity
         end
       end
-
-      # Use this when the mutation's return type was generated from `return_field`s.
-      # It delegates field lookups to the hash returned from `resolve`.
-      class Result
-        attr_reader :client_mutation_id
-        def initialize(client_mutation_id:, result:)
-          @client_mutation_id = client_mutation_id
-          result && result.each do |key, value|
-            self.public_send("#{key}=", value)
-          end
-        end
-
-        class << self
-          attr_accessor :mutation
-        end
-
-        def self.define_subclass(mutation_defn)
-          subclass = Class.new(self) do
-            attr_accessor(*mutation_defn.return_type.all_fields.map(&:name))
-            self.mutation = mutation_defn
-          end
-          subclass
-        end
-      end
-
-      module MutationInstrumentation
-        def self.instrument(type, field)
-          if field.mutation
-            new_resolve = MutationResolve.new(field.mutation, field.resolve_proc)
-            new_lazy_resolve = MutationResolve.new(field.mutation, field.lazy_resolve_proc)
-            field.redefine(resolve: new_resolve, lazy_resolve: new_lazy_resolve)
-          else
-            field
-          end
-        end
-      end
-
-      class MutationResolve
-        def initialize(mutation, resolve)
-          @mutation = mutation
-          @resolve = resolve
-          @wrap_result = mutation.has_generated_return_type?
-        end
-
-        def call(obj, args, ctx)
-          begin
-            mutation_result = @resolve.call(obj, args[:input], ctx)
-          rescue GraphQL::ExecutionError => err
-            mutation_result = err
-          end
-
-          if ctx.schema.lazy?(mutation_result)
-            mutation_result
-          else
-            build_result(mutation_result, args, ctx)
-          end
-        end
-
-        private
-
-        def build_result(mutation_result, args, ctx)
-          if mutation_result.is_a?(GraphQL::ExecutionError)
-            ctx.add_error(mutation_result)
-            mutation_result = nil
-          end
-
-          if @wrap_result
-            if mutation_result && !mutation_result.is_a?(Hash)
-              raise StandardError, "Expected `#{mutation_result}` to be a Hash."\
-                " Return a hash when using `return_field` or specify a custom `return_type`."
-            end
-
-            @mutation.result_class.new(client_mutation_id: args[:input][:clientMutationId], result: mutation_result)
-          else
-            mutation_result
-          end
-        end
-      end
     end
   end
 end

data/lib/graphql/relay/mutation/instrumentation.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+module GraphQL
+  module Relay
+    class Mutation
+      # @api private
+      module Instrumentation
+        # Modify mutation `return_field` resolves by wrapping the returned object
+        # in a {Mutation::Result}.
+        #
+        # By using an instrumention, we can apply our wrapper _last_,
+        # giving users access to the original resolve function in earlier instrumentation.
+        def self.instrument(type, field)
+          if field.mutation
+            new_resolve = Mutation::Resolve.new(field.mutation, field.resolve_proc)
+            new_lazy_resolve = Mutation::Resolve.new(field.mutation, field.lazy_resolve_proc)
+            field.redefine(resolve: new_resolve, lazy_resolve: new_lazy_resolve)
+          else
+            field
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/relay/mutation/resolve.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+module GraphQL
+  module Relay
+    class Mutation
+      # Wrap a user-provided resolve function,
+      # wrapping the returned value in a {Mutation::Result}.
+      # Also, pass the `clientMutationId` to that result object.
+      # @api private
+      class Resolve
+        def initialize(mutation, resolve)
+          @mutation = mutation
+          @resolve = resolve
+          @wrap_result = mutation.has_generated_return_type?
+        end
+
+        def call(obj, args, ctx)
+          begin
+            mutation_result = @resolve.call(obj, args[:input], ctx)
+          rescue GraphQL::ExecutionError => err
+            mutation_result = err
+          end
+
+          if ctx.schema.lazy?(mutation_result)
+            mutation_result
+          else
+            build_result(mutation_result, args, ctx)
+          end
+        end
+
+        private
+
+        def build_result(mutation_result, args, ctx)
+          if mutation_result.is_a?(GraphQL::ExecutionError)
+            ctx.add_error(mutation_result)
+            mutation_result = nil
+          end
+
+          if @wrap_result
+            if mutation_result && !mutation_result.is_a?(Hash)
+              raise StandardError, "Expected `#{mutation_result}` to be a Hash."\
+                " Return a hash when using `return_field` or specify a custom `return_type`."
+            end
+
+            @mutation.result_class.new(client_mutation_id: args[:input][:clientMutationId], result: mutation_result)
+          else
+            mutation_result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/relay/mutation/result.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+module GraphQL
+  module Relay
+    class Mutation
+      # Use this when the mutation's return type was generated from `return_field`s.
+      # It delegates field lookups to the hash returned from `resolve`.
+      # @api private
+      class Result
+        attr_reader :client_mutation_id
+        def initialize(client_mutation_id:, result:)
+          @client_mutation_id = client_mutation_id
+          result && result.each do |key, value|
+            self.public_send("#{key}=", value)
+          end
+        end
+
+        class << self
+          attr_accessor :mutation
+        end
+
+        # Build a subclass whose instances have a method
+        # for each of `mutation_defn`'s `return_field`s
+        # @param mutation_defn [GraphQL::Relay::Mutation]
+        # @return [Class]
+        def self.define_subclass(mutation_defn)
+          subclass = Class.new(self) do
+            mutation_result_methods = mutation_defn.return_type.all_fields.map do |f|
+              f.property || f.name
+            end
+            attr_accessor(*mutation_result_methods)
+            self.mutation = mutation_defn
+          end
+          subclass
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema.rb

@@ -445,7 +445,7 @@ module GraphQL
     def build_instrumented_field_map
       all_instrumenters = @instrumenters[:field] + [
         GraphQL::Relay::ConnectionInstrumentation,
-        GraphQL::Relay::Mutation::MutationInstrumentation,
+        GraphQL::Relay::Mutation::Instrumentation,
       ]
       @instrumented_field_map = InstrumentedFieldMap.new(self, all_instrumenters)
     end

data/lib/graphql/string_encoding_error.rb

@@ -4,7 +4,7 @@ module GraphQL
     attr_reader :string
     def initialize(str)
       @string = str
-      super("String \"#{str}\" was encoded as #{str.encoding}! GraphQL requires UTF-8 encoding.")
+      super("String \"#{str}\" was encoded as #{str.encoding}! GraphQL requires an encoding compatible with UTF-8.")
     end
   end
 end

data/lib/graphql/string_type.rb

@@ -4,10 +4,10 @@ GraphQL::STRING_TYPE = GraphQL::ScalarType.define do
   description "Represents textual data as UTF-8 character sequences. This type is most often used by GraphQL to represent free-form human-readable text."
 
   coerce_result ->(value, ctx) {
-    str = value.to_s
-    if str.encoding == Encoding::US_ASCII || str.encoding == Encoding::UTF_8
-      str
-    else
+    begin
+      str = value.to_s
+      str.encoding == Encoding::UTF_8 ? str : str.encode(Encoding::UTF_8)
+    rescue EncodingError
       err = GraphQL::StringEncodingError.new(str)
       ctx.schema.type_error(err, ctx)
     end

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.5.9"
+  VERSION = "1.5.10"
 end

data/spec/graphql/query/variables_spec.rb

@@ -248,4 +248,30 @@ describe GraphQL::Query::Variables do
       end
     end
   end
+
+  if ActionPack::VERSION::MAJOR > 3
+    describe "with a ActionController::Parameters" do
+      let(:query_string) { <<-GRAPHQL
+        query getCheeses($source: DairyAnimal!, $fatContent: Float!){
+          searchDairy(product: [{source: $source, fatContent: $fatContent}]) {
+            ... on Cheese { flavor }
+          }
+        }
+      GRAPHQL
+      }
+      let(:params) do
+        ActionController::Parameters.new(
+          "variables" => {
+            "source" => "COW",
+            "fatContent" => 0.4,
+          }
+        )
+      end
+
+      it "works" do
+        res = schema.execute(query_string, variables: params["variables"])
+        assert_equal 1, res["data"]["searchDairy"].length
+      end
+    end
+  end
 end

data/spec/graphql/relay/mutation_spec.rb

@@ -113,6 +113,21 @@ describe GraphQL::Relay::Mutation do
     assert_equal StarWars::IntroduceShipMutation, StarWars::IntroduceShipMutation.result_class.mutation
   end
 
+  describe "return_field ... property:" do
+    it "resolves correctly" do
+      query_str = <<-GRAPHQL
+        mutation {
+          introduceShip(input: {shipName: "Bagel", factionId: "1"}) {
+            aliasedFaction { name }
+          }
+        }
+      GRAPHQL
+      result = star_wars_query(query_str)
+      faction_name = result["data"]["introduceShip"]["aliasedFaction"]["name"]
+      assert_equal("Alliance to Restore the Republic", faction_name)
+    end
+  end
+
   describe "aliased methods" do
     describe "on an unreached mutation" do
       it 'still ensures definitions' do

data/spec/graphql/string_type_spec.rb

@@ -9,17 +9,41 @@ describe GraphQL::STRING_TYPE do
   end
 
   describe "coerce_result" do
+    let(:utf_8_str) { "foobar" }
+    let(:ascii_str) { "foobar".encode(Encoding::ASCII_8BIT) }
     let(:binary_str) { "\0\0\0foo\255\255\255".dup.force_encoding("BINARY") }
-    it "requires string to be encoded as UTF-8" do
-      err = assert_raises(GraphQL::StringEncodingError) {
-        string_type.coerce_isolated_result(binary_str)
-      }
 
-      assert_equal "String \"#{binary_str}\" was encoded as ASCII-8BIT! GraphQL requires UTF-8 encoding.", err.message
-      assert_equal binary_str, err.string
+    describe "encoding" do
+      subject { string_type.coerce_isolated_result(string) }
+
+      describe "when result is encoded as UTF-8" do
+        let(:string) { utf_8_str }
+
+        it "returns the string" do
+          assert_equal subject, string
+        end
+      end
+
+      describe "when the result is not UTF-8 but can be transcoded" do
+        let(:string) { ascii_str }
+
+        it "returns the string transcoded to UTF-8" do
+          assert_equal subject, string.encode(Encoding::UTF_8)
+        end
+      end
+
+      describe "when the result is not UTF-8 and cannot be transcoded" do
+        let(:string) { binary_str }
+
+        it "raises GraphQL::StringEncodingError" do
+          err = assert_raises(GraphQL::StringEncodingError) { subject }
+          assert_equal "String \"#{string}\" was encoded as ASCII-8BIT! GraphQL requires an encoding compatible with UTF-8.", err.message
+          assert_equal string, err.string
+        end
+      end
     end
 
-    describe "when the schema defines a custom hander" do
+    describe "when the schema defines a custom handler" do
       let(:schema) {
         GraphQL::Schema.define do
           query(GraphQL::ObjectType.define(name: "Query"))

data/spec/support/star_wars/schema.rb

@@ -183,6 +183,7 @@ module StarWars
     # Result may have access to these fields:
     return_field :shipEdge, Ship.edge_type
     return_field :faction, Faction
+    return_field :aliasedFaction, Faction, property: :aliased_faction
 
     # Here's the mutation operation:
     resolve ->(root_obj, inputs, ctx) {
@@ -216,7 +217,8 @@ module StarWars
         ship_edge = GraphQL::Relay::Edge.new(ship, ships_connection)
         result = {
           shipEdge: ship_edge,
-          faction: faction
+          faction: faction,
+          aliased_faction: faction,
         }
         if args["shipName"] == "Slave II"
           LazyWrapper.new(result)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.5.9
+  version: 1.5.10
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-19 00:00:00.000000000 Z
+date: 2017-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -428,6 +428,9 @@ files:
 - lib/graphql/relay/edge_type.rb
 - lib/graphql/relay/global_id_resolve.rb
 - lib/graphql/relay/mutation.rb
+- lib/graphql/relay/mutation/instrumentation.rb
+- lib/graphql/relay/mutation/resolve.rb
+- lib/graphql/relay/mutation/result.rb
 - lib/graphql/relay/node.rb
 - lib/graphql/relay/page_info.rb
 - lib/graphql/relay/range_add.rb