graphql 0.19.2 → 0.19.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c2492431f6efd112dd3a4aa0c2b26e17f2e45df2
-  data.tar.gz: cd351bd76f0bf2bf4e173c900710b317210767b7
+  metadata.gz: 49959ced421e4d175a2ab09abb1f70046fbeecc0
+  data.tar.gz: e9eb998841dff1511ea8d06f6482d779e39c0d4c
 SHA512:
-  metadata.gz: 3faf8b928d7cec65474d15cc3f29dd886f25f23d5b514d9427c578619e6c4ef8fbca048839f7633ad12ad61fae427bab5fe4eb0ff259afb8363b49524b063636
-  data.tar.gz: a7574edfbda2742ef46ce2bb70faf5d7f437aced4180f87b2c8c7b55f5a1e267608416ca70864187debe00efac594ece5b705fdfff9edf6b3b7be34875b40b3b
+  metadata.gz: 8f595c5ff5a2b3062f17ec9bb038de9f2cffb550308a34a61cd8ab7c3f65a5cb878c557ebcc0aa50c31c48808be1a5a4d61ec6d609be7a14b62044809b5d4c46
+  data.tar.gz: 1a0452062ac5a5de8ef7102d28d2c1395e1e1cc16a379c87e844c35d6f7beaa3b036932695a8a55c506218185a05aa15425820fe34ef0a428e54ae95e828305c

data/lib/graphql/input_object_type.rb

@@ -85,7 +85,7 @@ module GraphQL
         end
       end
 
-      GraphQL::Query::Arguments.new(input_values)
+      GraphQL::Query::Arguments.new(input_values, argument_definitions: arguments)
     end
 
     def coerce_result(value)

data/lib/graphql/introspection/introspection_query.rb

@@ -69,6 +69,22 @@ fragment TypeRef on __Type {
       ofType {
         kind
         name
+        ofType {
+          kind
+          name
+          ofType {
+            kind
+            name
+            ofType {
+              kind
+              name
+              ofType {
+                kind
+                name
+              }
+            }
+          }
+        }
       }
     }
   }

data/lib/graphql/query.rb

@@ -116,7 +116,6 @@ module GraphQL
       @validation_errors
     end
 
-
     # TODO this should probably contain error instances, not hashes
     # @return [Array<Hash>] Errors for this particular query run (eg, exceeds max complexity)
     def analysis_errors

data/lib/graphql/query/arguments.rb

@@ -6,10 +6,12 @@ module GraphQL
     class Arguments
       extend Forwardable
 
-      def initialize(values)
+      def initialize(values, argument_definitions:)
         @original_values = values
         @argument_values = values.inject({}) do |memo, (inner_key, inner_value)|
-          memo[inner_key.to_s] = wrap_value(inner_value)
+          string_key = inner_key.to_s
+          arg_defn = argument_definitions[string_key]
+          memo[string_key] = wrap_value(inner_value, arg_defn.type)
           memo
         end
       end
@@ -36,12 +38,17 @@ module GraphQL
 
       private
 
-      def wrap_value(value)
+      def wrap_value(value, arg_defn_type)
         case value
         when Array
-          value.map { |item| wrap_value(item) }
+          value.map { |item| wrap_value(item, arg_defn_type.of_type) }
         when Hash
-          self.class.new(value)
+          if arg_defn_type.unwrap.kind.input_object?
+            self.class.new(value, argument_definitions: arg_defn_type.arguments)
+          else
+            # It may be a custom scalar that coerces to a Hash
+            value
+          end
         else
           value
         end

data/lib/graphql/query/literal_input.rb

@@ -36,7 +36,7 @@ module GraphQL
             values_hash[arg_name] = arg_value
           end
         end
-        GraphQL::Query::Arguments.new(values_hash)
+        GraphQL::Query::Arguments.new(values_hash, argument_definitions: argument_defns)
       end
 
       module LiteralKindCoercers
@@ -60,7 +60,7 @@ module GraphQL
           def self.coerce(value, type, variables)
             hash = {}
             value.arguments.each do |arg|
-              field_type = type.input_fields[arg.name].type
+              field_type = type.arguments[arg.name].type
               hash[arg.name] = LiteralInput.coerce(field_type, arg.value, variables)
             end
             type.input_fields.each do |arg_name, arg_defn|
@@ -71,7 +71,7 @@ module GraphQL
                 end
               end
             end
-            Arguments.new(hash)
+            Arguments.new(hash, argument_definitions: type.arguments)
           end
         end
 

data/lib/graphql/relay/connection_type.rb

@@ -10,11 +10,12 @@ module GraphQL
         connection_type = ObjectType.define do
           name(connection_type_name)
           field :edges, types[edge_type] do
+            description "A list of edges."
             resolve -> (obj, args, ctx) {
               obj.edge_nodes.map { |item| edge_class.new(item, obj) }
             }
           end
-          field :pageInfo, !PageInfo, property: :page_info
+          field :pageInfo, !PageInfo, "Information to aid in pagination.", property: :page_info
           block && instance_eval(&block)
         end
 

data/lib/graphql/relay/edge_type.rb

@@ -4,8 +4,9 @@ module GraphQL
       def self.create_type(wrapped_type, name: nil, &block)
         GraphQL::ObjectType.define do
           name("#{wrapped_type.name}Edge")
-          field :node, wrapped_type
-          field :cursor, !types.String
+          description "An edge in a connection."
+          field :node, wrapped_type, "The item at the end of the edge."
+          field :cursor, !types.String, "A cursor for use in pagination."
           block && instance_eval(&block)
         end
       end

data/lib/graphql/relay/mutation.rb

@@ -51,11 +51,12 @@ module GraphQL
       include GraphQL::Define::InstanceDefinable
       accepts_definitions(
         :name, :description, :resolve,
+        :return_type,
         input_field: GraphQL::Define::AssignArgument,
         return_field: GraphQL::Define::AssignObjectField,
       )
       lazy_defined_attr_accessor :name, :description
-      lazy_defined_attr_accessor :fields, :arguments
+      lazy_defined_attr_accessor :fields, :arguments, :return_type
 
       # For backwards compat, but do we need this separate API?
       alias :return_fields :fields
@@ -64,21 +65,32 @@ module GraphQL
       def initialize
         @fields = {}
         @arguments = {}
+        @has_generated_return_type = false
       end
 
-      def resolve=(proc)
+      def has_generated_return_type?
+        # Trigger the generation of the return type, if it is dynamically generated:
+        return_type
+        @has_generated_return_type
+      end
+
+      def resolve=(new_resolve_proc)
         ensure_defined
-        @resolve_proc = proc
+
+        resolve_arity = get_arity(new_resolve_proc)
+        if resolve_arity == 2
+          warn("Mutation#resolve functions should be defined with three arguments: (root_obj, input, context). Two-argument mutation resolves are deprecated.")
+          new_resolve_proc = DeprecatedMutationResolve.new(new_resolve_proc)
+        end
+
+        @resolve_proc = MutationResolve.new(self, new_resolve_proc, wrap_result: has_generated_return_type?)
       end
 
       def field
         @field ||= begin
           ensure_defined
           relay_mutation = self
-          field_resolve_proc = -> (obj, args, ctx){
-            results_hash = @resolve_proc.call(args[:input], ctx)
-            Result.new(arguments: args, result: results_hash)
-          }
+          field_resolve_proc = @resolve_proc
           GraphQL::Field.define do
             type(relay_mutation.return_type)
             description(relay_mutation.description)
@@ -90,13 +102,14 @@ module GraphQL
       end
 
       def return_type
+        ensure_defined
         @return_type ||= begin
-          ensure_defined
+          @has_generated_return_type = true
           relay_mutation = self
           GraphQL::ObjectType.define do
             name("#{relay_mutation.name}Payload")
             description("Autogenerated return type of #{relay_mutation.name}")
-            field :clientMutationId, types.String, "A unique identifier for the client performing the mutation."
+            field :clientMutationId, types.String, "A unique identifier for the client performing the mutation.", property: :client_mutation_id
             relay_mutation.return_fields.each do |name, field_obj|
               field name, field: field_obj
             end
@@ -121,22 +134,71 @@ module GraphQL
         end
       end
 
+      def result_class
+        @result_class ||= begin
+          ensure_defined
+          Result.define_subclass(self)
+        end
+      end
+
+      private
+
+      def get_arity(callable)
+        case callable
+        when Proc
+          callable.arity
+        else
+          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 :arguments, :result
-        def initialize(arguments:, result:)
-          @arguments = arguments
-          @result = result
+        attr_reader :client_mutation_id
+        def initialize(client_mutation_id:, result:)
+          @client_mutation_id = client_mutation_id
+          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
+
+      class DeprecatedMutationResolve
+        def initialize(two_argument_resolve)
+          @two_argument_resolve = two_argument_resolve
+        end
+
+        def call(obj, args, ctx)
+          @two_argument_resolve.call(args[:input], ctx)
+        end
+      end
 
-        def clientMutationId
-          arguments[:input][:clientMutationId]
+      class MutationResolve
+        def initialize(mutation, resolve, wrap_result:)
+          @mutation = mutation
+          @resolve = resolve
+          @wrap_result = wrap_result
         end
 
-        def method_missing(name, *args, &block)
-          if result.key?(name)
-            result[name]
+        def call(obj, args, ctx)
+          mutation_result = @resolve.call(obj, args[:input], ctx)
+          if @wrap_result
+            @mutation.result_class.new(client_mutation_id: args[:input][:clientMutationId], result: mutation_result)
           else
-            super
+            mutation_result
           end
         end
       end

data/lib/graphql/relay/node.rb

@@ -9,8 +9,8 @@ module GraphQL
         # _may_ be modified.
         node_field = GraphQL::Field.define do
           type(GraphQL::Relay::Node.interface)
-          description("Fetches an object given its ID")
-          argument(:id, !types.ID, "ID of the object")
+          description("Fetches an object given its ID.")
+          argument(:id, !types.ID, "ID of the object.")
           resolve(GraphQL::Relay::Node::FindNode)
         end
 
@@ -24,7 +24,8 @@ module GraphQL
       def self.interface
         @interface ||= GraphQL::InterfaceType.define do
           name "Node"
-          field :id, !types.ID
+          description "An object with an ID."
+          field :id, !types.ID, "ID of the object."
         end
       end
 

data/lib/graphql/relay/page_info.rb

@@ -3,7 +3,7 @@ module GraphQL
     # Wrap a Connection and expose its page info
     PageInfo = GraphQL::ObjectType.define do
       name("PageInfo")
-      description("Metadata about a connection")
+      description("Information about pagination in a connection.")
       field :hasNextPage, !types.Boolean, "Indicates if there are more pages to fetch", property: :has_next_page
       field :hasPreviousPage, !types.Boolean, "Indicates if there are any pages prior to the current page", property: :has_previous_page
       field :startCursor, types.String, "When paginating backwards, the cursor to continue", property: :start_cursor

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

@@ -21,7 +21,7 @@ module GraphQL
           return GraphQL::Language::Visitor::SKIP
         end
 
-        field =  parent_type.get_field(ast_field.name)
+        field = context.schema.get_field(parent_type, ast_field.name)
         if field.nil?
           context.errors << message("Field '#{ast_field.name}' doesn't exist on type '#{parent_type.name}'", ast_field, context: context)
           return GraphQL::Language::Visitor::SKIP

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

@@ -13,8 +13,10 @@ module GraphQL
 
       def validate_is_input_type(node, context)
         type_name = get_type_name(node.type)
-        type = context.schema.types[type_name]
-        if !type.kind.input?
+        type = context.schema.types.fetch(type_name, nil)
+        if type.nil?
+          context.errors << message("#{type_name} isn't a defined input type (on $#{node.name})", node, context: context)
+        elsif !type.kind.input?
           context.errors << message("#{type.name} isn't a valid input type (on $#{node.name})", node, context: context)
         end
       end

data/lib/graphql/static_validation/type_stack.rb

@@ -48,15 +48,13 @@ module GraphQL
       private
 
       # Look up strategies by name and use singleton instance to push and pop
-      PUSH_STRATEGIES = Hash.new { |hash, key| hash[key] = get_strategy_for_node_class(key) }
-
-      def self.get_strategy_for_node_class(node_class)
-        node_class_name = node_class.name.split("::").last
+      PUSH_STRATEGIES = Hash.new do |hash, key|
+        node_class_name = key.name.split("::").last
         strategy_key = "#{node_class_name}Strategy"
-        const_defined?(strategy_key) ? const_get(strategy_key).new : NullStrategy.new
+        hash[key] = const_defined?(strategy_key) ? const_get(strategy_key) : NullStrategy
       end
 
-      class FragmentWithTypeStrategy
+      module FragmentWithTypeStrategy
         def push(stack, node)
           object_type = if node.type
             stack.schema.types.fetch(node.type, nil)
@@ -76,19 +74,24 @@ module GraphQL
         end
       end
 
-      class FragmentDefinitionStrategy < FragmentWithTypeStrategy
+      module FragmentDefinitionStrategy
+        extend FragmentWithTypeStrategy
+        module_function
         def push_path_member(stack, node)
           stack.path.push("fragment #{node.name}")
         end
       end
 
-      class InlineFragmentStrategy < FragmentWithTypeStrategy
+      module InlineFragmentStrategy
+        extend FragmentWithTypeStrategy
+        module_function
         def push_path_member(stack, node)
           stack.path.push("...#{node.type ? " on #{node.type}" : ""}")
         end
       end
 
-      class OperationDefinitionStrategy
+      module OperationDefinitionStrategy
+        module_function
         def push(stack, node)
           # eg, QueryType, MutationType
           object_type = stack.schema.root_type_for_operation(node.operation_type)
@@ -102,7 +105,8 @@ module GraphQL
         end
       end
 
-      class FieldStrategy
+      module FieldStrategy
+        module_function
         def push(stack, node)
           parent_type = stack.object_types.last
           parent_type = parent_type.unwrap
@@ -125,7 +129,8 @@ module GraphQL
         end
       end
 
-      class DirectiveStrategy
+      module DirectiveStrategy
+        module_function
         def push(stack, node)
           directive_defn = stack.schema.directives[node.name]
           stack.directive_definitions.push(directive_defn)
@@ -136,7 +141,8 @@ module GraphQL
         end
       end
 
-      class ArgumentStrategy
+      module ArgumentStrategy
+        module_function
         # Push `argument_defn` onto the stack.
         # It's possible that `argument_defn` will be nil.
         # Push it anyways so `pop` has something to pop.
@@ -165,7 +171,8 @@ module GraphQL
         end
       end
 
-      class FragmentSpreadStrategy
+      module FragmentSpreadStrategy
+        module_function
         def push(stack, node)
           stack.path.push("... #{node.name}")
         end
@@ -176,8 +183,7 @@ module GraphQL
       end
 
       # A no-op strategy (don't handle this node)
-      class NullStrategy
-        def self.new; self; end
+      module NullStrategy
         def self.push(stack, node);  end
         def self.pop(stack, node);   end
       end

data/lib/graphql/version.rb

@@ -1,3 +1,3 @@
 module GraphQL
-  VERSION = "0.19.2"
+  VERSION = "0.19.3"
 end

data/readme.md

@@ -148,4 +148,3 @@ If you're building a backend for [Relay](http://facebook.github.io/relay/), you'
   - Revisit guides, maybe split them into smaller, more specific pages
   - Put guide titles into the `<title />`
 - Document encrypted & versioned cursors
-- Eager load `Schema#types` after `.define { ... }`

data/spec/graphql/introspection/introspection_query_spec.rb

@@ -7,4 +7,52 @@ describe "GraphQL::Introspection::INTROSPECTION_QUERY" do
   it "runs" do
     assert(result["data"])
   end
+
+  it "handles deeply nested (<= 7) schemas" do
+     query_type =  GraphQL::ObjectType.define do
+        name "DeepQuery"
+        field :foo do
+          type !GraphQL::ListType.new(
+            of_type: !GraphQL::ListType.new(
+              of_type: !GraphQL::ListType.new(
+                of_type: GraphQL::FLOAT_TYPE
+              )
+            )
+          )
+        end
+     end
+
+     deep_schema = GraphQL::Schema.define do
+       query query_type
+     end
+
+     result = deep_schema.execute(query_string)
+     assert(GraphQL::Schema::Loader.load(result))
+  end
+
+  it "doesn't handle too deeply nested (< 8) schemas" do
+     query_type =  GraphQL::ObjectType.define do
+        name "DeepQuery"
+        field :foo do
+          type !GraphQL::ListType.new(
+            of_type: !GraphQL::ListType.new(
+              of_type: !GraphQL::ListType.new(
+                of_type: !GraphQL::ListType.new(
+                  of_type: GraphQL::FLOAT_TYPE
+                )
+              )
+            )
+          )
+        end
+     end
+
+     deep_schema = GraphQL::Schema.define do
+       query query_type
+     end
+
+     result = deep_schema.execute(query_string)
+     assert_raises(KeyError) {
+       GraphQL::Schema::Loader.load(result)
+     }
+  end
 end

data/spec/graphql/query/arguments_spec.rb

@@ -1,7 +1,29 @@
 require "spec_helper"
 
 describe GraphQL::Query::Arguments do
-  let(:arguments) { GraphQL::Query::Arguments.new({ a: 1, b: 2, c: GraphQL::Query::Arguments.new({ d: 3, e: 4}) }) }
+  let(:arguments) {
+    test_input_1 = GraphQL::InputObjectType.define do
+      name "TestInput1"
+      argument :d, types.Int
+      argument :e, types.Int
+    end
+
+    test_input_2 = GraphQL::InputObjectType.define do
+      name "TestInput2"
+      argument :a, types.Int
+      argument :b, types.Int
+      argument :c, !test_input_1
+    end
+
+    GraphQL::Query::Arguments.new({
+      a: 1,
+      b: 2,
+      c: GraphQL::Query::Arguments.new({
+        d: 3,
+        e: 4,
+      }, argument_definitions: test_input_1.arguments),
+    }, argument_definitions: test_input_2.arguments)
+  }
 
   it "returns keys as strings" do
     assert_equal(["a", "b", "c"], arguments.keys)
@@ -23,6 +45,25 @@ describe GraphQL::Query::Arguments do
     assert_equal({ a: 1, b: 2, c: { d: 3, e: 4 } }, arguments.to_h)
   end
 
+  describe "nested hashes" do
+    let(:input_type) {
+      test_input_type = GraphQL::InputObjectType.define do
+        name "TestInput"
+        argument :a, types.Int
+        argument :b, test_input_type
+        argument :c, types.Int # will be a hash
+      end
+    }
+    it "wraps input objects, but not other hashes" do
+      args = GraphQL::Query::Arguments.new(
+        {a: 1, b: {a: 2}, c: {a: 3}},
+        argument_definitions: input_type.arguments
+      )
+      assert args["b"].is_a?(GraphQL::Query::Arguments)
+      assert args["c"].is_a?(Hash)
+    end
+  end
+
   describe "#key?" do
     let(:arg_values) { [] }
     let(:schema) {

data/spec/graphql/relay/mutation_spec.rb

@@ -56,5 +56,51 @@ describe GraphQL::Relay::Mutation do
     assert_equal IntroduceShipMutation, IntroduceShipMutation.field.mutation
     assert_equal IntroduceShipMutation, IntroduceShipMutation.return_type.mutation
     assert_equal IntroduceShipMutation, IntroduceShipMutation.input_type.mutation
+    assert_equal IntroduceShipMutation, IntroduceShipMutation.result_class.mutation
+  end
+
+  describe "providing a return type" do
+    let(:custom_return_type) {
+      GraphQL::ObjectType.define do
+        name "CustomReturnType"
+        field :name, types.String
+      end
+    }
+
+    let(:mutation) {
+      custom_type = custom_return_type
+      GraphQL::Relay::Mutation.define do
+        name "CustomReturnTypeTest"
+        return_type custom_type
+        resolve -> (input, ctx) {
+          OpenStruct.new(name: "Custom Return Type Test")
+        }
+      end
+    }
+
+    let(:schema) {
+      mutation_field = mutation.field
+
+      mutation_root = GraphQL::ObjectType.define do
+        name "Mutation"
+        field :custom, mutation_field
+      end
+
+      GraphQL::Schema.define do
+        mutation(mutation_root)
+      end
+    }
+
+    it "uses the provided type" do
+      assert_equal custom_return_type, mutation.return_type
+      assert_equal custom_return_type, mutation.field.type
+
+      result = schema.execute("mutation { custom(input: {}) { name } }")
+      assert_equal "Custom Return Type Test", result["data"]["custom"]["name"]
+    end
+
+    it "doesn't get a mutation in the metadata" do
+      assert_equal nil, custom_return_type.mutation
+    end
   end
 end

data/spec/graphql/static_validation/rules/variables_are_input_types_spec.rb

@@ -10,6 +10,7 @@ describe GraphQL::StaticValidation::VariablesAreInputTypes do
       $interface: AnimalProduct!,
       $object:    Milk = 1,
       $objects:   [Cheese]!,
+      $unknownType: Nonsense,
     ) {
       cheese(id: $id) { source }
       __type(name: $str) { name }
@@ -34,5 +35,11 @@ describe GraphQL::StaticValidation::VariablesAreInputTypes do
       "locations"=>[{"line"=>7, "column"=>7}],
       "fields"=>["query getCheese"],
     })
+
+    assert_includes(errors, {
+      "message"=>"Nonsense isn't a defined input type (on $unknownType)",
+      "locations"=>[{"line"=>8, "column"=>7}],
+      "fields"=>["query getCheese"],
+    })
   end
 end

data/spec/support/star_wars_schema.rb

@@ -155,7 +155,7 @@ IntroduceShipMutation = GraphQL::Relay::Mutation.define do
   return_field :faction, Faction
 
   # Here's the mutation operation:
-  resolve -> (inputs, ctx) {
+  resolve -> (root_obj, inputs, ctx) {
     faction_id = inputs["factionId"]
     ship = STAR_WARS_DATA.create_ship(inputs["shipName"], faction_id)
     faction = STAR_WARS_DATA["Faction"][faction_id]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 0.19.2
+  version: 0.19.3
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-06 00:00:00.000000000 Z
+date: 2016-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: codeclimate-test-reporter
@@ -550,7 +550,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: A GraphQL server implementation for Ruby