graphql 1.8.14 → 1.8.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a0b109c83a9f06148fa278726ab57bd844f1b225
-  data.tar.gz: e0fa04d26e12feac797ff4a04ad34f1b792c3bea
+  metadata.gz: a2d518263838aebce2b708ac2ac6938e782a486c
+  data.tar.gz: 84fe5c02047ea67acf4a9950cbb14bcfd6d9fbfa
 SHA512:
-  metadata.gz: 674fffbfd89b1b90910bb28965d6a8b0dfee83440c55c73a765edf4d1cd622c9e8090691b4dbc61c7c80fdaac59b04c66dc9ebc4c83e58dd4f4f6f29350473f2
-  data.tar.gz: 405121d3f4ae2973eebc1059a0e6fcb3d577bf00dd9378929314fc1cd01c2f4b2a49ffcabfc66f6343d0f04d787b7cbabb5666c3d305936a416de6280b6ea15c
+  metadata.gz: 99fc75e928c224adf82a8658b9f8cd0a821f6909e2775bd58c401fb2192db43f440f4d1a7bb9f22fb4a5fdebd5f5a80235e566dd9b0e80df365b8a566893b994
+  data.tar.gz: d9ee1715ba8eac2d2b4cc788fe78d3383722a27f69966d140bc90e68a7564622f7e239653f2e9581471fa33c0339f822a3b415db9f2b0ce325fbebfa1c80f190

data/lib/graphql/execution/execute.rb

@@ -264,20 +264,22 @@ module GraphQL
               )
             when GraphQL::TypeKinds::UNION, GraphQL::TypeKinds::INTERFACE
               query = field_ctx.query
-              resolved_type = field_type.resolve_type(value, field_ctx)
-              possible_types = query.possible_types(field_type)
-
-              if !possible_types.include?(resolved_type)
-                parent_type = field_ctx.irep_node.owner_type
-                type_error = GraphQL::UnresolvedTypeError.new(value, field_defn, parent_type, resolved_type, possible_types)
-                field_ctx.schema.type_error(type_error, field_ctx)
-                PROPAGATE_NULL
-              else
-                resolve_value(
-                  value,
-                  resolved_type,
-                  field_ctx,
-                )
+              resolved_type_or_lazy = field_type.resolve_type(value, field_ctx)
+              query.schema.after_lazy(resolved_type_or_lazy) do |resolved_type|
+                possible_types = query.possible_types(field_type)
+
+                if !possible_types.include?(resolved_type)
+                  parent_type = field_ctx.irep_node.owner_type
+                  type_error = GraphQL::UnresolvedTypeError.new(value, field_defn, parent_type, resolved_type, possible_types)
+                  field_ctx.schema.type_error(type_error, field_ctx)
+                  PROPAGATE_NULL
+                else
+                  resolve_value(
+                    value,
+                    resolved_type,
+                    field_ctx,
+                  )
+                end
               end
             else
               raise("Unknown type kind: #{field_type.kind}")

data/lib/graphql/query/arguments.rb

@@ -168,7 +168,7 @@ module GraphQL
             memo[key] = unwrap_value(value)
             memo
           end
-        when GraphQL::Query::Arguments
+        when GraphQL::Query::Arguments, GraphQL::Schema::InputObject
           value.to_h
         else
           value

data/lib/graphql/schema.rb

@@ -480,17 +480,20 @@ module GraphQL
         yield(type, object, ctx)
       end
 
-      if type_result.respond_to?(:graphql_definition)
-        type_result = type_result.graphql_definition
-      end
-
       if type_result.nil?
         nil
-      elsif !type_result.is_a?(GraphQL::BaseType)
-        type_str = "#{type_result} (#{type_result.class.name})"
-        raise "resolve_type(#{object}) returned #{type_str}, but it should return a GraphQL type"
       else
-        type_result
+        after_lazy(type_result) do |resolved_type_result|
+          if resolved_type_result.respond_to?(:graphql_definition)
+            resolved_type_result = resolved_type_result.graphql_definition
+          end
+          if !resolved_type_result.is_a?(GraphQL::BaseType)
+            type_str = "#{resolved_type_result} (#{resolved_type_result.class.name})"
+            raise "resolve_type(#{object}) returned #{type_str}, but it should return a GraphQL type"
+          else
+            resolved_type_result
+          end
+        end
       end
     end
 

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

@@ -91,7 +91,7 @@ module GraphQL
                   # For lists with nil, we need another nil check here
                   nil
                 else
-                  concrete_type = case @inner_return_type
+                  concrete_type_or_lazy = case @inner_return_type
                   when GraphQL::UnionType, GraphQL::InterfaceType
                     ctx.query.resolve_type(@inner_return_type, inner_obj)
                   when GraphQL::ObjectType
@@ -100,12 +100,15 @@ module GraphQL
                     raise "unexpected proxying type #{@inner_return_type} for #{inner_obj} at #{ctx.owner_type}.#{ctx.field.name}"
                   end
 
-                  if concrete_type && (object_class = concrete_type.metadata[:type_class])
-                    # use the query-level context here, since it won't be field-specific anyways
-                    query_ctx = ctx.query.context
-                    object_class.authorized_new(inner_obj, query_ctx)
-                  else
-                    inner_obj
+                  # .resolve_type may have returned a lazy
+                  ctx.schema.after_lazy(concrete_type_or_lazy) do |concrete_type|
+                    if concrete_type && (object_class = concrete_type.metadata[:type_class])
+                      # use the query-level context here, since it won't be field-specific anyways
+                      query_ctx = ctx.query.context
+                      object_class.authorized_new(inner_obj, query_ctx)
+                    else
+                      inner_obj
+                    end
                   end
                 end
               end

data/lib/graphql/schema/resolver.rb

@@ -199,13 +199,13 @@ module GraphQL
         # 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|
-          begin
-            if application_object.nil?
-              raise LoadApplicationObjectFailedError.new(argument: argument, id: id, object: application_object)
-            end
-            # Double-check that the located object is actually of this type
-            # (Don't want to allow arbitrary access to objects this way)
-            application_object_type = context.schema.resolve_type(lookup_as_type, application_object, context)
+          if application_object.nil?
+            raise LoadApplicationObjectFailedError.new(argument: argument, id: id, object: application_object)
+          end
+          # Double-check that the located object is actually of this type
+          # (Don't want to allow arbitrary access to objects this way)
+          resolved_application_object_type = context.schema.resolve_type(lookup_as_type, application_object, context)
+          context.schema.after_lazy(resolved_application_object_type) do |application_object_type|
             possible_object_types = context.schema.possible_types(lookup_as_type)
             if !possible_object_types.include?(application_object_type)
               raise LoadApplicationObjectFailedError.new(argument: argument, id: id, object: application_object)
@@ -229,11 +229,11 @@ module GraphQL
                 application_object
               end
             end
-          rescue LoadApplicationObjectFailedError => err
-            # pass it to a handler
-            load_application_object_failed(err)
           end
         end
+      rescue LoadApplicationObjectFailedError => err
+        # pass it to a handler
+        load_application_object_failed(err)
       end
 
       def load_application_object_failed(err)

data/lib/graphql/version.rb

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

data/spec/integration/rails/graphql/relay/mutation_spec.rb

@@ -336,4 +336,52 @@ describe GraphQL::Relay::Mutation do
       assert_equal(expected, result)
     end
   end
+
+  describe 'supports new input object definition with old mutation definition' do
+    let(:some_attribute_type) do
+      Class.new(GraphQL::Schema::InputObject) do
+        graphql_name 'SomeAttribute'
+        argument :something, String, required: false
+      end
+    end
+
+    let(:do_something_mutation) do
+      some_attribute = some_attribute_type
+
+      GraphQL::Relay::Mutation.define do
+        name 'DoSomethingMutation'
+        input_field :someAttributes, types[some_attribute.graphql_definition]
+
+        return_field :anything, types.String
+
+        resolve ->(_obj, inputs, _ctx) {
+          {
+            anything: inputs.to_h['someAttributes'][0].class.to_s
+          }
+        }
+      end
+    end
+
+    let(:mutation_type) do
+      do_something = do_something_mutation
+
+      Class.new(GraphQL::Schema::Object) do
+        graphql_name 'Mutation'
+        field :doSomething, field: do_something.field
+      end
+    end
+
+    let(:schema) do
+      mutation = mutation_type
+
+      Class.new(GraphQL::Schema) do
+        mutation mutation
+      end
+    end
+
+    it 'converts to hash the whole input' do
+      result = schema.execute('mutation { doSomething(input: {someAttributes: [{something: "string"}]}) { anything } }')
+      assert_equal 'Hash', result['data']['doSomething']['anything']
+    end
+  end
 end

data/spec/support/jazz.rb

@@ -310,10 +310,12 @@ module Jazz
     possible_types Musician, Ensemble
 
     def self.resolve_type(object, context)
-      if object.is_a?(Models::Ensemble)
-        Ensemble
-      else
-        Musician
+      GraphQL::Execution::Lazy.new do
+        if object.is_a?(Models::Ensemble)
+          Ensemble
+        else
+          Musician
+        end
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.8.14
+  version: 1.8.15
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-09 00:00:00.000000000 Z
+date: 2019-02-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips