graphql 1.8.0.pre7 → 1.8.0.pre8

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

@@ -109,8 +109,8 @@ module GraphQL
           return string unless string.include?("_")
           camelized = string.split('_').map(&:capitalize).join
           camelized[0] = camelized[0].downcase
-          if string.start_with?("__")
-            camelized = "__#{camelized}"
+          if (match_data = string.match(/\A(_+)/))
+            camelized = "#{match_data[0]}#{camelized}"
           end
           camelized
         end

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

@@ -7,8 +7,9 @@ module GraphQL
         # Add a field to this object or interface with the given definition
         # @see {GraphQL::Schema::Field#initialize} for method signature
         # @return [void]
-        def field(*args, &block)
-          field_defn = field_class.new(*args, &block)
+        def field(*args, **kwargs, &block)
+          kwargs[:owner] = self
+          field_defn = field_class.new(*args, **kwargs, &block)
           add_field(field_defn)
           nil
         end

data/lib/graphql/schema/object.rb

@@ -3,6 +3,8 @@
 module GraphQL
   class Schema
     class Object < GraphQL::Schema::Member
+      extend GraphQL::Schema::Member::AcceptsDefinition
+
       # @return [Object] the application object this type is wrapping
       attr_reader :object
 
@@ -22,8 +24,8 @@ module GraphQL
           new_interfaces.each do |int|
             if int.is_a?(Class) && int < GraphQL::Schema::Interface
               # Add the graphql field defns
-              int.fields.each do |_name, field|
-                add_field(field)
+              int.fields.each do |name, field|
+                own_fields[name] = field
               end
               # And call the implemented hook
               int.apply_implemented(self)

data/lib/graphql/schema/scalar.rb

@@ -2,6 +2,8 @@
 module GraphQL
   class Schema
     class Scalar < GraphQL::Schema::Member
+      extend GraphQL::Schema::Member::AcceptsDefinition
+
       class << self
         def coerce_input(val, ctx)
           raise NotImplementedError, "#{self.name}.coerce_input(val, ctx) must prepare GraphQL input (#{val.inspect}) for Ruby processing"

data/lib/graphql/schema/traversal.rb

@@ -136,6 +136,9 @@ Some late-bound types couldn't be resolved:
               visit_fields(schema, type_defn)
             when GraphQL::InterfaceType
               visit_fields(schema, type_defn)
+              type_defn.orphan_types.each do |t|
+                visit(schema, t, "Orphan type for #{type_defn.name}")
+              end
             when GraphQL::UnionType
               type_defn.possible_types.each do |t|
                 @union_memberships[t.name] << type_defn

data/lib/graphql/schema/union.rb

@@ -2,30 +2,25 @@
 module GraphQL
   class Schema
     class Union < GraphQL::Schema::Member
+      extend GraphQL::Schema::Member::AcceptsDefinition
+
       class << self
         def possible_types(*types)
           if types.any?
-            @own_possible_types = types
+            @possible_types = types
           else
-            all_possible_types = own_possible_types
-            inherited_possible_types = (superclass < GraphQL::Schema::Union ? superclass.possible_types : [])
-            all_possible_types += inherited_possible_types
+            all_possible_types = @possible_types || []
+            all_possible_types += super if defined?(super)
             all_possible_types.uniq
           end
         end
 
-        def own_possible_types
-          @own_possible_types ||= []
-        end
-
         def to_graphql
           type_defn = GraphQL::UnionType.new
           type_defn.name = graphql_name
           type_defn.description = description
           type_defn.possible_types = possible_types
-          # If an instance method is defined, use it as a
-          # resolve type hook, via the class method
-          if method_defined?(:resolve_type)
+          if respond_to?(:resolve_type)
             type_defn.resolve_type = method(:resolve_type)
           end
           type_defn

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.8.0.pre7"
+  VERSION = "1.8.0.pre8"
 end

data/spec/graphql/argument_spec.rb

@@ -32,6 +32,27 @@ describe GraphQL::Argument do
       assert_equal GraphQL::STRING_TYPE, arg.type
     end
 
+    it "accepts a definition block after defining kwargs" do
+      arg = GraphQL::Argument.from_dsl(:foo, GraphQL::STRING_TYPE) do
+        description "my type is #{target.type}"
+      end
+
+      assert_equal "my type is String", arg.description
+    end
+
+    it "accepts a definition block with existing arg" do
+      existing = GraphQL::Argument.define do
+        name "bar"
+        type GraphQL::STRING_TYPE
+      end
+
+      arg = GraphQL::Argument.from_dsl(:foo, existing) do
+        description "Description for an existing field."
+      end
+
+      assert_equal "Description for an existing field.", arg.description
+    end
+
     it "creates an argument from dsl arguments" do
       arg = GraphQL::Argument.from_dsl(
         :foo,

data/spec/graphql/base_type_spec.rb

@@ -28,6 +28,28 @@ describe GraphQL::BaseType do
     assert_equal ["Cheese"], Dummy::CheeseType.metadata[:class_names]
   end
 
+  describe "#name" do
+    describe "when containing spaces" do
+      BaseNameSpaceTest = GraphQL::BaseType.define do
+        name "Some Invalid Name"
+      end
+
+      it "is invalid" do
+        assert_raises(GraphQL::InvalidNameError) { BaseNameSpaceTest.name }
+      end
+    end
+
+    describe "when containing colons" do
+      BaseNameColonsTest = GraphQL::BaseType.define do
+        name "Some::Invalid::Name"
+      end
+
+      it 'is invalid' do
+        assert_raises(GraphQL::InvalidNameError) { BaseNameColonsTest.name }
+      end
+    end
+  end
+
   describe "name" do
     it "fails with a helpful message" do
       error = assert_raises RuntimeError do

data/spec/graphql/enum_type_spec.rb

@@ -37,21 +37,34 @@ describe GraphQL::EnumType do
     end
   end
 
-  describe "invalid names" do
-    it "rejects names with a space" do
+  describe "invalid values" do
+    it "rejects value names with a space" do
       assert_raises(GraphQL::InvalidNameError) {
-        InvalidEnumTest = GraphQL::EnumType.define do
-          name "InvalidEnumTest"
+        InvalidEnumValueTest = GraphQL::EnumType.define do
+          name "InvalidEnumValueTest"
 
           value("SPACE IN VALUE", "Invalid enum because it contains spaces", value: 1)
         end
 
         # Force evaluation
-        InvalidEnumTest.name
+        InvalidEnumValueTest.name
       }
     end
   end
 
+  describe "invalid name" do
+    it "reject names with invalid format" do
+      assert_raises(GraphQL::InvalidNameError) do
+        InvalidEnumNameTest = GraphQL::EnumType.define do
+          name "Some::Invalid::Name"
+        end
+
+        # Force evaluation
+        InvalidEnumNameTest.name
+      end
+    end
+  end
+
   describe "values that are Arrays" do
     let(:schema) {
       enum = GraphQL::EnumType.define do

data/spec/graphql/execution/execute_spec.rb

@@ -163,10 +163,10 @@ describe GraphQL::Execution::Execute do
           "execute_field",
           "execute_query",
           "lazy_loader",
-          "execute_field",
           "execute_field_lazy",
           "execute_field",
           "execute_field_lazy",
+          "execute_field",
           "execute_field_lazy",
           "execute_field_lazy",
           "execute_query_lazy",
@@ -177,8 +177,8 @@ describe GraphQL::Execution::Execute do
         field_1_eager, field_2_eager,
           query_eager, lazy_loader,
           # field 3 is eager-resolved _during_ field 1's lazy resolve
-          field_3_eager, field_1_lazy,
-          field_4_eager, field_2_lazy,
+          field_1_lazy, field_3_eager,
+          field_2_lazy, field_4_eager,
           # field 3 didn't finish above, it's resolved in the next round
           field_3_lazy, field_4_lazy,
           query_lazy, multiplex = exec_traces

data/spec/graphql/input_object_type_spec.rb

@@ -218,6 +218,19 @@ describe GraphQL::InputObjectType do
           assert_equal(expected, actual)
         end
       end
+
+      describe 'with invalid name' do
+        it 'raises the correct error' do
+          assert_raises(GraphQL::InvalidNameError) do
+            InvalidInputTest = GraphQL::InputObjectType.define do
+              name "Some::Invalid Name"
+            end
+
+            # Force evaluation
+            InvalidInputTest.name
+          end
+        end
+      end
     end
   end
 

data/spec/graphql/interface_type_spec.rb

@@ -92,6 +92,18 @@ describe GraphQL::InterfaceType do
       assert_equal 3, interface.fields.size
       assert_equal 4, interface_2.fields.size
     end
+
+    it "copies orphan types without affecting the original" do
+      interface = GraphQL::InterfaceType.define do
+        name "AInterface"
+        orphan_types [Dummy::HoneyType]
+      end
+
+      interface_2 = interface.dup
+      interface_2.orphan_types << Dummy::CheeseType
+      assert_equal 1, interface.orphan_types.size
+      assert_equal 2, interface_2.orphan_types.size
+    end
   end
 
   describe "#resolve_type" do

data/spec/graphql/language/nodes_spec.rb

@@ -2,18 +2,6 @@
 require "spec_helper"
 
 describe GraphQL::Language::Nodes::AbstractNode do
-  describe "child and scalar attributes" do
-    it "are inherited by node subclasses" do
-      subclassed_directive = Class.new(GraphQL::Language::Nodes::Directive)
-
-      assert_equal GraphQL::Language::Nodes::Directive.scalar_attributes,
-        subclassed_directive.scalar_attributes
-
-      assert_equal GraphQL::Language::Nodes::Directive.child_attributes,
-        subclassed_directive.child_attributes
-    end
-  end
-
   describe "#filename" do
     it "is set after .parse_file" do
       filename = "spec/support/parser/filename_example.graphql"

data/spec/graphql/language/parser_spec.rb

@@ -44,6 +44,80 @@ describe GraphQL::Language::Parser do
     assert_equal schema_string, document.to_query_string
   end
 
+  describe "implements" do
+    it "parses when there are no interfaces" do
+      schema = "
+        type A {
+          a: String
+        }
+      "
+
+      document = subject.parse(schema)
+
+      assert_equal [], document.definitions[0].interfaces.map(&:name)
+    end
+
+    it "parses with leading ampersand" do
+      schema = "
+        type A implements & B {
+          a: String
+        }
+      "
+
+      document = subject.parse(schema)
+
+      assert_equal ["B"], document.definitions[0].interfaces.map(&:name)
+    end
+
+    it "parses with leading ampersand and multiple interfaces" do
+      schema = "
+        type A implements & B & C {
+          a: String
+        }
+      "
+
+      document = subject.parse(schema)
+
+      assert_equal ["B", "C"], document.definitions[0].interfaces.map(&:name)
+    end
+
+    it "parses without leading ampersand" do
+      schema = "
+        type A implements B {
+          a: String
+        }
+      "
+
+      document = subject.parse(schema)
+
+      assert_equal ["B"], document.definitions[0].interfaces.map(&:name)
+    end
+
+    it "parses without leading ampersand and multiple interfaces" do
+      schema = "
+        type A implements B & C {
+          a: String
+        }
+      "
+
+      document = subject.parse(schema)
+
+      assert_equal ["B", "C"], document.definitions[0].interfaces.map(&:name)
+    end
+
+    it "supports the old way of parsing multiple interfaces for backwards compatibility" do
+      schema = "
+        type A implements B, C {
+          a: String
+        }
+      "
+
+      document = subject.parse(schema)
+
+      assert_equal ["B", "C"], document.definitions[0].interfaces.map(&:name)
+    end
+  end
+
   describe ".parse_file" do
     it "assigns filename to all nodes" do
       example_filename = "spec/support/parser/filename_example.graphql"

data/spec/graphql/language/printer_spec.rb

@@ -115,7 +115,7 @@ describe GraphQL::Language::Printer do
           # Union description
           union AnnotatedUnion @onUnion = A | B
 
-          type Foo implements Bar {
+          type Foo implements Bar & AnnotatedInterface {
             one: Type
             two(argument: InputType!): Type
             three(argument: InputType, other: String): Int

data/spec/graphql/object_type_spec.rb

@@ -60,6 +60,27 @@ describe GraphQL::ObjectType do
 
       assert_raises(ArgumentError) { type.name }
     end
+
+    it "doesnt convolute field names that differ with underscore" do
+      interface = Class.new(GraphQL::Schema::Interface) do
+        graphql_name 'TestInterface'
+        description 'Requires an id'
+
+        field :id, GraphQL::ID_TYPE, null: false
+      end
+
+      object = Class.new(GraphQL::Schema::Object) do
+        graphql_name 'TestObject'
+        implements interface
+        global_id_field :id
+
+        # When the validation for `id` is run for `_id`, it will fail because
+        # GraphQL::STRING_TYPE cannot be transformed into a GraphQL::ID_TYPE
+        field :_id, String, description: 'database id', null: true
+      end
+
+      assert_equal nil, GraphQL::Schema::Validation.validate(object.to_graphql)
+    end
   end
 
   it "accepts fields definition" do

data/spec/graphql/relay/range_add_spec.rb

@@ -70,7 +70,11 @@ describe GraphQL::Relay::RangeAdd do
       field :add_item, add_item.field
     end
 
-    GraphQL::Schema.define(query: query, mutation: mutation, cursor_encoder: PassThroughEncoder)
+    Class.new(GraphQL::Schema) do
+      self.query(query)
+      self.mutation(mutation)
+      self.cursor_encoder(PassThroughEncoder)
+    end
   }
 
 

data/spec/graphql/relay/relation_connection_spec.rb

@@ -117,6 +117,13 @@ describe GraphQL::Relay::RelationConnection do
       assert_equal true, get_page_info(result)["hasNextPage"]
       assert_equal true, get_page_info(result)["hasPreviousPage"]
 
+      last_cursor = get_last_cursor(result)
+      result = with_bidirectional_pagination {
+        star_wars_query(query_string, "last" => 1, "before" => last_cursor)
+      }
+      assert_equal true, get_page_info(result)["hasNextPage"]
+      assert_equal false, get_page_info(result)["hasPreviousPage"]
+
       result = star_wars_query(query_string, "first" => 100)
       last_cursor = get_last_cursor(result)
 
@@ -129,7 +136,6 @@ describe GraphQL::Relay::RelationConnection do
       }
       assert_equal true, get_page_info(result)["hasNextPage"]
       assert_equal true, get_page_info(result)["hasPreviousPage"]
-
     end
 
     it 'slices the result' do