graphql 1.4.3 → 1.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cda98acc4cef5d2d8e4c9c77cd9ac5f5139cc38a
-  data.tar.gz: 184b72d444de078b443453bca6f0a4d64d8cf0b9
+  metadata.gz: 3e792ef4481683e6c02e730a49a55d514e3117bd
+  data.tar.gz: 60f5a4bd233004203b0a3249e91d1c1ac4c99fec
 SHA512:
-  metadata.gz: cf7c368fd8d9ef704580aa2956e2813db1e3efbd748f1d9836d58b17ae5afaca3df2d623750dd9546688e42ab1cb5c0be26f6bbe46ea3f7d837788c8fc00fe92
-  data.tar.gz: ce531eb4ad6cd87b947c9c5fbd68d5cd14fef266950a3448e02659d02e8bc7db10c7d9d206ea12751d059c01392ed952facf938c3cddfd53dfb21404b554d83f
+  metadata.gz: fc9cc9c7581fb346daf8eaff35d1b7183c4ed89fc9c8c077827e71f5a63418c9d717983d2af661c700a5aade7a2c262714e01b809bd53a241c018b807de169cd
+  data.tar.gz: 631b382abd20a9e9060cda878287ea87df1d227e55cb410038755e99c38697007ab188fce7ff4ca7ed935e64912e663fe10e63c935c2727f53b19cbceda71570

data/lib/graphql/argument.rb

@@ -14,13 +14,17 @@ module GraphQL
   #   GraphQL::InputObjectType.define do
   #     argument :newName, !types.String
   #   end
-  #
+
   class Argument
     include GraphQL::Define::InstanceDefinable
-    accepts_definitions :name, :type, :description, :default_value
-    attr_accessor :type, :description, :default_value, :name
+    accepts_definitions :name, :type, :description, :default_value, :as
+    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)
+    def initialize_copy(other)
+      @expose_as = nil
+    end
 
     def default_value?
       !!@has_default_value
@@ -44,5 +48,10 @@ module GraphQL
     def type
       @clean_type ||= GraphQL::BaseType.resolve_related_type(@dirty_type)
     end
+
+    # @return [String] The name of this argument inside `resolve` functions
+    def expose_as
+      @expose_as ||= (@as || @name).to_s
+    end
   end
 end

data/lib/graphql/base_type.rb

@@ -158,5 +158,15 @@ module GraphQL
     def define_edge(**kwargs, &block)
       GraphQL::Relay::EdgeType.create_type(self, **kwargs, &block)
     end
+
+    # Return a GraphQL string for the type definition
+    # @param schema [GraphQL::Schema]
+    # @param printer [GraphQL::Schema::Printer]
+    # @see {GraphQL::Schema::Printer#initialize for additional options}
+    # @return [String] type definition
+    def to_definition(schema, printer: nil, **args)
+      printer ||= GraphQL::Schema::Printer.new(schema, **args)
+      printer.print_type(self)
+    end
   end
 end

data/lib/graphql/define/assign_argument.rb

@@ -10,7 +10,7 @@ module GraphQL
           GraphQL::Argument.new
         end
 
-        unsupported_keys = rest.keys - [:default_value]
+        unsupported_keys = rest.keys - [:default_value, :as]
         if unsupported_keys.any?
           raise ArgumentError.new("unknown keyword#{unsupported_keys.length > 1 ? 's' : ''}: #{unsupported_keys.join(', ')}")
         end
@@ -19,6 +19,7 @@ module GraphQL
         type && argument.type = type
         description && argument.description = description
         rest.key?(:default_value) && argument.default_value = rest[:default_value]
+        argument.as = rest[:as]
 
         target.arguments[name.to_s] = argument
       end

data/lib/graphql/field.rb

@@ -213,15 +213,14 @@ module GraphQL
       @clean_type ||= GraphQL::BaseType.resolve_related_type(@dirty_type)
     end
 
-    # You can only set a field's name _once_ -- this to prevent
-    # passing the same {Field} to multiple `.field` calls.
-    #
-    # This is important because {#name} may be used by {#resolve}.
     def name=(new_name)
-      if @name.nil?
-        @name = new_name
-      elsif @name != new_name
-        raise("Can't rename an already-named field. (Tried to rename \"#{@name}\" to \"#{new_name}\".) If you're passing a field with the `field:` argument, make sure it's an unused instance of GraphQL::Field.")
+      old_name = @name
+      @name = new_name
+
+      if old_name != new_name && @resolve_proc.is_a?(Field::Resolve::NameResolve)
+        # Since the NameResolve would use the old field name,
+        # reset resolve proc when the name has changed
+        self.resolve = nil
       end
     end
 

data/lib/graphql/query/arguments.rb

@@ -10,9 +10,10 @@ module GraphQL
       def initialize(values, argument_definitions:)
         @original_values = values
         @argument_values = values.inject({}) do |memo, (inner_key, inner_value)|
-          string_key = inner_key.to_s
-          arg_defn = argument_definitions[string_key]
+          arg_defn = argument_definitions[inner_key.to_s]
+
           arg_value = wrap_value(inner_value, arg_defn.type)
+          string_key = arg_defn.expose_as
           memo[string_key] = ArgumentValue.new(string_key, arg_value, arg_defn)
           memo
         end

data/lib/graphql/relay/base_connection.rb

@@ -47,7 +47,7 @@ module GraphQL
         end
       end
 
-      attr_reader :nodes, :arguments, :max_page_size, :parent, :field
+      attr_reader :nodes, :arguments, :max_page_size, :parent, :field, :context
 
       # Make a connection, wrapping `nodes`
       # @param nodes [Object] The collection of nodes

data/lib/graphql/relay/connection_type.rb

@@ -10,14 +10,15 @@ module GraphQL
 
       # Create a connection which exposes edges of this type
       def self.create_type(wrapped_type, edge_type: nil, edge_class: nil, nodes_field: ConnectionType.default_nodes_field, &block)
-        edge_type ||= wrapped_type.edge_type
         edge_class ||= GraphQL::Relay::Edge
-        connection_type_name = "#{wrapped_type.name}Connection"
-        connection_type_description = "The connection type for #{wrapped_type.name}."
+        edge_type ||= wrapped_type.edge_type
 
-        connection_type = ObjectType.define do
-          name(connection_type_name)
-          description(connection_type_description)
+        # Any call that would trigger `wrapped_type.ensure_defined`
+        # must be inside this lazy block, otherwise we get weird
+        # cyclical dependency errors :S
+        ObjectType.define do
+          name("#{wrapped_type.name}Connection")
+          description("The connection type for #{wrapped_type.name}.")
           field :edges, types[edge_type] do
             description "A list of edges."
             resolve ->(obj, args, ctx) {
@@ -35,8 +36,6 @@ module GraphQL
           field :pageInfo, !PageInfo, "Information to aid in pagination.", property: :page_info
           block && instance_eval(&block)
         end
-
-        connection_type
       end
     end
   end

data/lib/graphql/relay/mutation.rb

@@ -53,12 +53,19 @@ module GraphQL
       accepts_definitions(
         :name, :description, :resolve,
         :return_type,
+        :return_interfaces,
         input_field: GraphQL::Define::AssignArgument,
         return_field: GraphQL::Define::AssignObjectField,
       )
-      attr_accessor :name, :description, :fields, :arguments, :return_type
+      attr_accessor :name, :description, :fields, :arguments, :return_type, :return_interfaces
+
+      ensure_defined(
+        :input_fields, :return_fields, :name, :description,
+        :fields, :arguments, :return_type,
+        :return_interfaces, :resolve=,
+        :field, :result_class, :input_type
+      )
 
-      ensure_defined(:name, :description, :fields, :arguments, :return_type, :resolve=, :field, :result_class, :input_type)
       # For backwards compat, but do we need this separate API?
       alias :return_fields :fields
       alias :input_fields :arguments
@@ -93,6 +100,10 @@ module GraphQL
         end
       end
 
+      def return_interfaces
+        @return_interfaces ||= []
+      end
+
       def return_type
         @return_type ||= begin
           @has_generated_return_type = true
@@ -101,6 +112,7 @@ module GraphQL
             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.", property: :client_mutation_id
+            interfaces relay_mutation.return_interfaces
             relay_mutation.return_fields.each do |name, field_obj|
               field name, field: field_obj
             end
@@ -195,6 +207,11 @@ module GraphQL
           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

data/lib/graphql/relay/node.rb

@@ -4,7 +4,7 @@ module GraphQL
     # Helpers for working with Relay-specific Node objects.
     module Node
       # @return [GraphQL::Field] a field for finding objects by their global ID.
-      def self.field
+      def self.field(resolve: nil)
         # We have to define it fresh each time because
         # its name will be modified and its description
         # _may_ be modified.
@@ -12,17 +12,17 @@ module GraphQL
           type(GraphQL::Relay::Node.interface)
           description("Fetches an object given its ID.")
           argument(:id, !types.ID, "ID of the object.")
-          resolve(GraphQL::Relay::Node::FindNode)
+          resolve(resolve || GraphQL::Relay::Node::FindNode)
           relay_node_field(true)
         end
       end
 
-      def self.plural_field
+      def self.plural_field(resolve: nil)
         GraphQL::Field.define do
           type(!types[GraphQL::Relay::Node.interface])
           description("Fetches a list of objects given a list of IDs.")
           argument(:ids, !types[!types.ID], "IDs of the objects.")
-          resolve(GraphQL::Relay::Node::FindNodes)
+          resolve(resolve || GraphQL::Relay::Node::FindNodes)
           relay_nodes_field(true)
         end
       end

data/lib/graphql/relay/relation_connection.rb

@@ -51,7 +51,7 @@ module GraphQL
           if before
             [previous_offset, 0].max
           elsif last
-            count(nodes) - last
+            [count(nodes) - last, 0].max
           else
             previous_offset
           end

data/lib/graphql/schema/printer.rb

@@ -3,41 +3,91 @@ module GraphQL
   class Schema
     # Used to convert your {GraphQL::Schema} to a GraphQL schema string
     #
-    # @example print your schema to standard output
+    # @example print your schema to standard output (via helper)
     #   MySchema = GraphQL::Schema.define(query: QueryType)
     #   puts GraphQL::Schema::Printer.print_schema(MySchema)
     #
-    module Printer
-      extend self
+    # @example print your schema to standard output
+    #   MySchema = GraphQL::Schema.define(query: QueryType)
+    #   puts GraphQL::Schema::Printer.new(MySchema).print_schema
+    #
+    # @example print a single type to standard output
+    #   query_root = GraphQL::ObjectType.define do
+    #     name "Query"
+    #     description "The query root of this schema"
+    #
+    #     field :post do
+    #       type post_type
+    #       resolve ->(obj, args, ctx) { Post.find(args["id"]) }
+    #     end
+    #   end
+    #
+    #   post_type = GraphQL::ObjectType.define do
+    #     name "Post"
+    #     description "A blog post"
+    #
+    #     field :id, !types.ID
+    #     field :title, !types.String
+    #     field :body, !types.String
+    #   end
+    #
+    #   MySchema = GraphQL::Schema.define(query: query_root)
+    #
+    #   printer = GraphQL::Schema::Printer.new(MySchema)
+    #   puts printer.print_type(post_type)
+    #
+    class Printer
+      attr_reader :schema, :warden
 
-      # Return a GraphQL schema string for the defined types in the schema
+      # @param schema [GraphQL::Schema]
       # @param context [Hash]
       # @param only [<#call(member, ctx)>]
       # @param except [<#call(member, ctx)>]
-      # @param schema [GraphQL::Schema]
-      def print_schema(schema, context: nil, only: nil, except: nil)
-        blacklist = if only
-          ->(m, ctx) { !(IS_USER_DEFINED_MEMBER.call(m) && only.call(m, ctx)) }
-        elsif except
-          ->(m, ctx) { !IS_USER_DEFINED_MEMBER.call(m) || except.call(m, ctx) }
-        else
-          ->(m, ctx) { !IS_USER_DEFINED_MEMBER.call(m) }
-        end
+      # @param introspection [Boolean] Should include the introspection types in the string?
+      def initialize(schema, context: nil, only: nil, except: nil, introspection: false)
+        @schema = schema
+        @context = context
 
-        warden = GraphQL::Schema::Warden.new(blacklist, schema: schema, context: context)
-
-        print_filtered_schema(schema, warden: warden)
+        blacklist = build_blacklist(only, except, introspection: introspection)
+        @warden = GraphQL::Schema::Warden.new(blacklist, schema: @schema, context: @context)
       end
 
       # Return the GraphQL schema string for the introspection type system
-      def print_introspection_schema
+      def self.print_introspection_schema
         query_root = ObjectType.define(name: "Root")
         schema = GraphQL::Schema.define(query: query_root)
         blacklist = ->(m, ctx) { m == query_root }
+        printer = new(schema, except: blacklist, introspection: true)
+        printer.print_schema
+      end
+
+      # Return a GraphQL schema string for the defined types in the schema
+      # @param schema [GraphQL::Schema]
+      # @param context [Hash]
+      # @param only [<#call(member, ctx)>]
+      # @param except [<#call(member, ctx)>]
+      def self.print_schema(schema, **args)
+        printer = new(schema, **args)
+        printer.print_schema
+      end
 
-        warden = GraphQL::Schema::Warden.new(blacklist, schema: schema, context: nil)
+      # Return a GraphQL schema string for the defined types in the schema
+      def print_schema
+        directive_definitions = warden.directives.map { |directive| print_directive(directive) }
+
+        printable_types = warden.types.reject(&:default_scalar?)
+
+        type_definitions = printable_types
+          .sort_by(&:name)
+          .map { |type| print_type(type) }
 
-        print_filtered_schema(schema, warden: warden)
+        [print_schema_definition].compact
+                                 .concat(directive_definitions)
+                                 .concat(type_definitions).join("\n\n")
+      end
+
+      def print_type(type)
+        TypeKindPrinters::STRATEGIES.fetch(type.kind).print(warden, type)
       end
 
       private
@@ -56,21 +106,27 @@ module GraphQL
 
       private_constant :IS_USER_DEFINED_MEMBER
 
-      def print_filtered_schema(schema, warden:)
-        directive_definitions = warden.directives.map { |directive| print_directive(warden, directive) }
-
-        printable_types = warden.types.reject(&:default_scalar?)
-
-        type_definitions = printable_types
-          .sort_by(&:name)
-          .map { |type| print_type(warden, type) }
-
-        [print_schema_definition(warden, schema)].compact
-                                         .concat(directive_definitions)
-                                         .concat(type_definitions).join("\n\n")
+      def build_blacklist(only, except, introspection:)
+        if introspection
+          if only
+            ->(m, ctx) { !only.call(m, ctx) }
+          elsif except
+            except
+          else
+            ->(m, ctx) { false }
+          end
+        else
+          if only
+            ->(m, ctx) { !(IS_USER_DEFINED_MEMBER.call(m) && only.call(m, ctx)) }
+          elsif except
+            ->(m, ctx) { !IS_USER_DEFINED_MEMBER.call(m) || except.call(m, ctx) }
+          else
+            ->(m, ctx) { !IS_USER_DEFINED_MEMBER.call(m) }
+          end
+        end
       end
 
-      def print_schema_definition(warden, schema)
+      def print_schema_definition
         if (schema.query.nil? || schema.query.name == 'Query') &&
            (schema.mutation.nil? || schema.mutation.name == 'Mutation') &&
            (schema.subscription.nil? || schema.subscription.name == 'Subscription')
@@ -89,11 +145,7 @@ module GraphQL
         "schema {\n#{operations}}"
       end
 
-      def print_type(warden, type)
-        TypeKindPrinters::STRATEGIES.fetch(type.kind).print(warden, type)
-      end
-
-      def print_directive(warden, directive)
+      def print_directive(directive)
         TypeKindPrinters::DirectivePrinter.print(warden, directive)
       end
 

data/lib/graphql/version.rb

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

data/spec/graphql/argument_spec.rb

@@ -41,4 +41,20 @@ describe GraphQL::Argument do
     assert argument.default_value.nil?
     assert !argument.default_value?
   end
+
+  describe "#as, #exposed_as" do
+    it "accepts a `as` property to define the arg name at resolve time" do
+      argument = GraphQL::Argument.define(name: :favoriteFood, type: GraphQL::STRING_TYPE, as: :favFood)
+      assert_equal argument.as, :favFood
+    end
+
+    it "uses `name` or `as` for `expose_as`" do
+      arg_1 = GraphQL::Argument.define(name: :favoriteFood, type: GraphQL::STRING_TYPE, as: :favFood)
+      assert_equal arg_1.expose_as, "favFood"
+      arg_2 = GraphQL::Argument.define(name: :favoriteFood, type: GraphQL::STRING_TYPE)
+      assert_equal arg_2.expose_as, "favoriteFood"
+      arg_3 = arg_2.redefine { as :ff }
+      assert_equal arg_3.expose_as, "ff"
+    end
+  end
 end

data/spec/graphql/base_type_spec.rb

@@ -46,4 +46,40 @@ describe GraphQL::BaseType do
       refute_equal obj_edge, obj_2.connection_type
     end
   end
+
+  describe "#to_definition" do
+    post_type = GraphQL::ObjectType.define do
+      name "Post"
+      description "A blog post"
+
+      field :id, !types.ID
+      field :title, !types.String
+      field :body, !types.String
+    end
+
+    query_root = GraphQL::ObjectType.define do
+      name "Query"
+      description "The query root of this schema"
+
+      field :post do
+        type post_type
+        resolve ->(obj, args, ctx) { Post.find(args["id"]) }
+      end
+    end
+
+    schema = GraphQL::Schema.define(query: query_root)
+
+    expected = <<TYPE
+# A blog post
+type Post {
+  id: ID!
+  title: String!
+  body: String!
+}
+TYPE
+
+    it "prints the type definition" do
+      assert_equal expected.chomp, post_type.to_definition(schema)
+    end
+  end
 end

data/spec/graphql/field_spec.rb

@@ -78,15 +78,6 @@ describe GraphQL::Field do
   end
 
   describe "#name" do
-    it "can't be reassigned" do
-      field = GraphQL::Field.define do
-        name("something")
-      end
-      assert_equal "something", field.name
-      assert_raises(RuntimeError) { field.name = "somethingelse" }
-      assert_equal "something", field.name
-    end
-
     it "must be a string" do
       dummy_query = GraphQL::ObjectType.define do
         name "QueryType"
@@ -174,6 +165,47 @@ describe GraphQL::Field do
       assert_equal 2, int_field_2.arguments.size
     end
 
+    it "rebuilds when the resolve_proc is default NameResolve" do
+      int_field = GraphQL::Field.define do
+        name "a"
+      end
+
+      int_field_2 = int_field.redefine(name: "b")
+
+      object = Struct.new(:a, :b).new(1, 2)
+
+      assert_equal 1, int_field.resolve_proc.call(object, nil, nil)
+      assert_equal 2, int_field_2.resolve_proc.call(object, nil, nil)
+    end
+
+    it "keeps the same resolve_proc when it is not a NameResolve" do
+      int_field = GraphQL::Field.define do
+        name "a"
+        resolve ->(obj, _, _) { 'GraphQL is Kool' }
+      end
+
+      int_field_2 = int_field.redefine(name: "b")
+
+      assert_equal(
+        int_field.resolve_proc.call(nil, nil, nil),
+        int_field_2.resolve_proc.call(nil, nil, nil)
+      )
+    end
+
+    it "keeps the same resolve_proc when it is a built in property resolve" do
+      int_field = GraphQL::Field.define do
+        name "a"
+        property :c
+      end
+
+      int_field_2 = int_field.redefine(name: "b")
+
+      object = Struct.new(:a, :b, :c).new(1, 2, 3)
+
+      assert_equal 3, int_field.resolve_proc.call(object, nil, nil)
+      assert_equal 3, int_field_2.resolve_proc.call(object, nil, nil)
+    end
+
     it "copies metadata, even out-of-bounds assignments" do
       int_field = GraphQL::Field.define do
         metadata(:a, 1)

data/spec/graphql/query/arguments_spec.rb

@@ -13,7 +13,7 @@ describe GraphQL::Query::Arguments do
       name "TestInput2"
       argument :a, types.Int
       argument :b, types.Int
-      argument :c, !test_input_1
+      argument :c, !test_input_1, as: :inputObject
     end
 
     GraphQL::Query::Arguments.new({
@@ -55,7 +55,7 @@ describe GraphQL::Query::Arguments do
     expected_type_info =[
       ["a", 1, "Int"],
       ["b", 2, "Int"],
-      ["c", { d: 3, e: 4 }, "TestInput1"],
+      ["inputObject", { d: 3, e: 4 }, "TestInput1"],
     ]
     assert_equal expected_type_info, type_info
   end
@@ -72,7 +72,7 @@ describe GraphQL::Query::Arguments do
     expected_hash = {
       "A" => 1,
       "B" => 2,
-      "C" => { d: 3 , e: 4 },
+      "INPUTOBJECT" => { d: 3 , e: 4 },
     }
     assert_equal expected_hash, new_arguments.to_h
   end
@@ -97,10 +97,14 @@ describe GraphQL::Query::Arguments do
   end
 
   describe "#[]" do
+    it "fetches using specified `as` keyword" do
+      assert arguments["inputObject"].is_a?(GraphQL::Query::Arguments)
+    end
+
     it "returns the value at that key" do
       assert_equal 1, arguments["a"]
       assert_equal 1, arguments[:a]
-      assert arguments["c"].is_a?(GraphQL::Query::Arguments)
+      assert arguments["inputObject"].is_a?(GraphQL::Query::Arguments)
     end
 
     it "returns nil for missing keys" do
@@ -127,7 +131,7 @@ describe GraphQL::Query::Arguments do
         field :argTest, types.Int do
           argument :a, types.Int
           argument :b, types.Int, default_value: 2
-          argument :c, types.Int
+          argument :c, types.Int, as: :specialKeyName
           argument :d, test_input_type
           resolve ->(obj, args, ctx) {
             arg_values_array << args
@@ -146,6 +150,14 @@ describe GraphQL::Query::Arguments do
       assert_equal false, arguments.key?("f")
     end
 
+    it "detects keys using `as` to rename an arg at resolve time" do
+      schema.execute("{ argTest(c: 1) }")
+
+      last_args = arg_values.last
+
+      assert_equal true, last_args.key?(:specialKeyName)
+    end
+
     it "works from query literals" do
       schema.execute("{ argTest(a: 1) }")
 

data/spec/graphql/relay/array_connection_spec.rb

@@ -82,6 +82,11 @@ describe GraphQL::Relay::ArrayConnection do
 
       result = star_wars_query(query_string, "last" => 2)
       assert_equal(["Millenium Falcon", "Home One"], get_names(result))
+
+      result = star_wars_query(query_string, "last" => 10)
+      assert_equal(["X-Wing", "Y-Wing", "A-Wing", "Millenium Falcon", "Home One"], get_names(result))
+      assert_equal(false, result["data"]["rebels"]["ships"]["pageInfo"]["hasNextPage"])
+      assert_equal(false, result["data"]["rebels"]["ships"]["pageInfo"]["hasPreviousPage"])
     end
 
     it 'handles cursors beyond the bounds of the array' do

data/spec/graphql/relay/base_connection_spec.rb

@@ -15,6 +15,22 @@ describe GraphQL::Relay::BaseConnection do
     end
   end
 
+  describe "#context" do
+    module Encoder
+      module_function
+      def encode(str, nonce: false); str; end
+      def decode(str, nonce: false); str; end
+    end
+
+    let(:schema) { OpenStruct.new(cursor_encoder: Encoder) }
+    let(:context) { OpenStruct.new(schema: schema) }
+
+    it "Has public access to the field context" do
+      conn = GraphQL::Relay::BaseConnection.new([], {}, context: context)
+      assert_equal context, conn.context
+    end
+  end
+
   describe "#encode / #decode" do
     module ReverseEncoder
       module_function

data/spec/graphql/relay/mutation_spec.rb

@@ -49,6 +49,36 @@ describe GraphQL::Relay::Mutation do
     assert_equal "Slave II", result["data"]["introduceShip"]["shipEdge"]["node"]["name"]
   end
 
+  it "raises when using a generated return type and resolve doesnt return a Hash" do
+    bad_mutation = GraphQL::Relay::Mutation.define do
+      name 'BadMutation'
+      description 'A mutation type that doesnt return a hash'
+
+      input_field :input, types.String
+      return_field :return, types.String
+
+      resolve ->(_, _, _) {
+        # Should have been { return: 'my_bad_return_value' }
+        'my_bad_return_value'
+      }
+    end
+
+    root = GraphQL::ObjectType.define do
+      name "MutationRoot"
+      field :bad, bad_mutation.field
+    end
+
+    schema = GraphQL::Schema.define { mutation(root) }
+
+    exception = assert_raises do
+      puts schema.execute('mutation { bad(input: { input: "graphql" }) { return } }')
+    end
+
+    expected_message = "Expected `my_bad_return_value` to be a Hash."\
+      " Return a hash when using `return_field` or specify a custom `return_type`."
+    assert_equal expected_message, exception.message
+  end
+
   it "returns the result & clientMutationId" do
     result = star_wars_query(query_string, "clientMutationId" => "1234")
     expected = {"data" => {
@@ -167,6 +197,70 @@ describe GraphQL::Relay::Mutation do
     end
   end
 
+  describe "specifying return interfaces" do
+    let(:result_interface) {
+      GraphQL::InterfaceType.define do
+        name "ResultInterface"
+        field :success, !types.Boolean
+        field :notice, types.String
+      end
+    }
+
+    let(:error_interface) {
+      GraphQL::InterfaceType.define do
+        name "ErrorInterface"
+        field :error, types.String
+      end
+    }
+
+    let(:mutation) {
+      interfaces = [result_interface, error_interface]
+      GraphQL::Relay::Mutation.define do
+        name "ReturnTypeWithInterfaceTest"
+
+        return_field :name, types.String
+
+        return_interfaces interfaces
+
+        resolve ->(obj, input, ctx) {
+          {
+            name: "Type Specific Field",
+            success: true,
+            notice: "Success Interface Field",
+            error: "Error Interface Field"
+          }
+        }
+      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)
+        resolve_type ->(obj, ctx) { "not really used" }
+      end
+    }
+
+    it 'makes the mutation type implement the interfaces' do
+      assert_equal [result_interface, error_interface], mutation.return_type.interfaces
+    end
+
+    it "returns interface values and specific ones" do
+      result = schema.execute('mutation { custom(input: {clientMutationId: "123"}) { name, success, notice, error, clientMutationId } }')
+      assert_equal "Type Specific Field", result["data"]["custom"]["name"]
+      assert_equal "Success Interface Field", result["data"]["custom"]["notice"]
+      assert_equal true, result["data"]["custom"]["success"]
+      assert_equal "Error Interface Field", result["data"]["custom"]["error"]
+      assert_equal "123", result["data"]["custom"]["clientMutationId"]
+    end
+  end
+
   describe "handling errors" do
     it "supports returning an error in resolve" do
       result = star_wars_query(query_string, "clientMutationId" => "5678", "shipName" => "Millennium Falcon")

data/spec/graphql/relay/node_spec.rb

@@ -9,6 +9,45 @@ describe GraphQL::Relay::Node do
   end
 
   describe ".field" do
+    describe "with custom resolver" do
+      it "executes the custom resolve instead of relay default" do
+        id = "resolver_is_hardcoded_so_this_does_not_matter"
+
+        result = star_wars_query(%|{
+          nodeWithCustomResolver(id: "#{id}") {
+            id,
+            ... on Faction {
+              name
+              ships(first: 1) {
+                edges {
+                 node {
+                   name
+                   }
+                }
+              }
+            }
+          }
+        }|)
+
+        expected = {"data" => {
+          "nodeWithCustomResolver"=>{
+            "id"=>"RmFjdGlvbi0x",
+            "name"=>"Alliance to Restore the Republic",
+            "ships"=>{
+              "edges"=>[
+                {"node"=>{
+                    "name" => "X-Wing"
+                  }
+                }
+              ]
+            }
+          }
+        }}
+
+        assert_equal(expected, result)
+      end
+    end
+
     describe "Custom global IDs" do
       before do
         # TODO: make the schema eager-load so we can remove this
@@ -92,6 +131,55 @@ describe GraphQL::Relay::Node do
   end
 
   describe ".plural_identifying_field" do
+    describe "with custom resolver" do
+      it "executes the custom resolve instead of relay default" do
+        id = ["resolver_is_hardcoded_so_this_does_not_matter", "another_id"]
+
+        result = star_wars_query(%|{
+          nodesWithCustomResolver(ids: ["#{id[0]}", "#{id[1]}"]) {
+            id,
+            ... on Faction {
+              name
+              ships(first: 1) {
+                edges {
+                 node {
+                   name
+                   }
+                }
+              }
+            }
+          }
+        }|)
+
+        expected = {
+          "data" => {
+            "nodesWithCustomResolver" => [
+              {
+                "id" => "RmFjdGlvbi0x",
+                "name" => "Alliance to Restore the Republic",
+                "ships" => {
+                  "edges"=>[
+                    { "node" => { "name" => "X-Wing" } }
+                  ]
+                }
+              },
+              {
+                "id" => "RmFjdGlvbi0y",
+                "name" => "Galactic Empire",
+                "ships" => {
+                  "edges"=>[
+                    { "node" => { "name" => "TIE Fighter" } }
+                  ]
+                }
+              },
+            ]
+          }
+        }
+
+        assert_equal(expected, result)
+      end
+    end
+
     it 'finds objects by ids' do
       id = GraphQL::Schema::UniqueWithinType.encode("Faction", "1")
       id2 = GraphQL::Schema::UniqueWithinType.encode("Faction", "2")

data/spec/graphql/relay/relation_connection_spec.rb

@@ -97,6 +97,11 @@ describe GraphQL::Relay::RelationConnection do
 
       result = star_wars_query(query_string, "last" => 2)
       assert_equal(["Shield Generator", "Headquarters"], get_names(result))
+
+      result = star_wars_query(query_string, "last" => 10)
+      assert_equal(["Death Star", "Shield Generator", "Headquarters"], get_names(result))
+      assert_equal(false, result["data"]["empire"]["bases"]["pageInfo"]["hasNextPage"])
+      assert_equal(false, result["data"]["empire"]["bases"]["pageInfo"]["hasPreviousPage"])
     end
 
     it 'handles cursors beyond the bounds of the array' do

data/spec/graphql/schema/printer_spec.rb

@@ -590,4 +590,20 @@ SCHEMA
     context = { names: ["Varied", "Image", "Sub"] }
     assert_equal expected.chomp, schema.to_definition(context: context, except: except_filter)
   end
+
+  describe "#print_type" do
+    it "returns the type schema as a string" do
+      expected = <<SCHEMA
+# A blog post
+type Post {
+  id: ID!
+  title: String!
+  body: String!
+  comments: [Comment!]
+  comments_count: Int! @deprecated(reason: \"Use \\\"comments\\\".\")
+}
+SCHEMA
+      assert_equal expected.chomp, GraphQL::Schema::Printer.new(schema).print_type(schema.types['Post'])
+    end
+  end
 end

data/spec/support/dummy/schema.rb

@@ -328,9 +328,9 @@ module Dummy
     description "The root for mutations in this schema"
     field :pushValue, !types[!types.Int] do
       description("Push a value onto a global array :D")
-      argument :value, !types.Int
+      argument :value, !types.Int, as: :val
       resolve ->(o, args, ctx) {
-        GLOBAL_VALUES << args[:value]
+        GLOBAL_VALUES << args[:val]
         GLOBAL_VALUES
       }
     end

data/spec/support/star_wars/schema.rb

@@ -8,6 +8,8 @@ module StarWars
     interfaces [GraphQL::Relay::Node.interface]
     global_id_field :id
     field :name, types.String
+    # Test cyclical connection types:
+    connection :ships, Ship.connection_type
   end
 
   BaseType = GraphQL::ObjectType.define do
@@ -218,7 +220,13 @@ module StarWars
     end
 
     field :node, GraphQL::Relay::Node.field
+    field :nodeWithCustomResolver, GraphQL::Relay::Node.field(
+      resolve: ->(_, _, _) { StarWars::DATA["Faction"]["1"] }
+    )
     field :nodes, GraphQL::Relay::Node.plural_field
+    field :nodesWithCustomResolver, GraphQL::Relay::Node.plural_field(
+      resolve: ->(_, _, _) { [StarWars::DATA["Faction"]["1"], StarWars::DATA["Faction"]["2"]] }
+    )
   end
 
   MutationType = GraphQL::ObjectType.define do

data/spec/tmp/app/graphql/types/bird_type.rb

@@ -0,0 +1,5 @@
+Types::BirdType = GraphQL::InterfaceType.define do
+  name "Bird"
+  field :wingspan, !types.Int
+  field :foliage, types[Types::ColorType]
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.4.3
+  version: 1.4.4
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-08 00:00:00.000000000 Z
+date: 2017-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: codeclimate-test-reporter
@@ -553,6 +553,7 @@ files:
 - spec/support/star_wars/data.rb
 - spec/support/star_wars/schema.rb
 - spec/support/static_validation_helpers.rb
+- spec/tmp/app/graphql/types/bird_type.rb
 homepage: http://github.com/rmosolgo/graphql-ruby
 licenses:
 - MIT
@@ -573,7 +574,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
 summary: A GraphQL server implementation for Ruby
@@ -682,3 +683,4 @@ test_files:
 - spec/support/star_wars/data.rb
 - spec/support/star_wars/schema.rb
 - spec/support/static_validation_helpers.rb
+- spec/tmp/app/graphql/types/bird_type.rb