graphql 1.7.13 → 1.7.14

data/lib/graphql/language/parser.y

@@ -152,12 +152,8 @@ rule
     | operation_type
     | schema_keyword
 
-  name_list:
-      name             { return [make_node(:TypeName, name: val[0])] }
-    | name_list name   { val[0] << make_node(:TypeName, name: val[1]) }
-
   enum_value_definition:
-    enum_name directives_list_opt { return make_node(:EnumValueDefinition, name: val[0], directives: val[1], description: get_description(val[0])) }
+    enum_name directives_list_opt { return make_node(:EnumValueDefinition, name: val[0], directives: val[1], description: get_description(val[0]), position_source: val[0]) }
 
   enum_value_definitions:
       enum_value_definition                        { return [val[0]] }
@@ -306,11 +302,21 @@ rule
 
   implements_opt:
       /* none */ { return [] }
-    | IMPLEMENTS name_list { return val[1] }
+    | IMPLEMENTS AMP interfaces_list { return val[2] }
+    | IMPLEMENTS interfaces_list { return val[1] }
+    | IMPLEMENTS legacy_interfaces_list { return val[1] }
+
+  interfaces_list:
+      name                     { return [make_node(:TypeName, name: val[0], position_source: val[0])] }
+    | interfaces_list AMP name { val[0] << make_node(:TypeName, name: val[2], position_source: val[2]) }
+
+  legacy_interfaces_list:
+      name                        { return [make_node(:TypeName, name: val[0], position_source: val[0])] }
+    | legacy_interfaces_list name { val[0] << make_node(:TypeName, name: val[1], position_source: val[1]) }
 
   input_value_definition:
       name COLON type default_value_opt directives_list_opt {
-        return make_node(:InputValueDefinition, name: val[0], type: val[2], default_value: val[3], directives: val[4], description: get_description(val[0]))
+        return make_node(:InputValueDefinition, name: val[0], type: val[2], default_value: val[3], directives: val[4], description: get_description(val[0]), position_source: val[0])
       }
 
   input_value_definition_list:
@@ -323,7 +329,7 @@ rule
 
   field_definition:
       name arguments_definitions_opt COLON type directives_list_opt {
-        return make_node(:FieldDefinition, name: val[0], arguments: val[1], type: val[3], directives: val[4], description: get_description(val[0]))
+        return make_node(:FieldDefinition, name: val[0], arguments: val[1], type: val[3], directives: val[4], description: get_description(val[0]), position_source: val[0])
       }
 
   field_definition_list:

data/lib/graphql/language/printer.rb

@@ -154,7 +154,7 @@ module GraphQL
       def print_object_type_definition(object_type)
         out = print_description(object_type)
         out << "type #{object_type.name}"
-        out << " implements " << object_type.interfaces.map(&:name).join(", ") unless object_type.interfaces.empty?
+        out << " implements " << object_type.interfaces.map(&:name).join(" & ") unless object_type.interfaces.empty?
         out << print_directives(object_type.directives)
         out << print_field_definitions(object_type.fields)
       end
@@ -339,7 +339,7 @@ module GraphQL
         when Hash
           "{#{node.map { |k, v| "#{k}: #{print_node(v)}" }.join(", ")}}".dup
         else
-          raise TypeError
+          GraphQL::Language.serialize(node.to_s)
         end
       end
 

data/lib/graphql/object_type.rb

@@ -102,11 +102,6 @@ module GraphQL
       dirty_ifaces.concat(interfaces)
     end
 
-    def name=(name)
-      GraphQL::NameValidator.validate!(name)
-      @name = name
-    end
-
     protected
 
     attr_reader :dirty_interfaces, :dirty_inherited_interfaces

data/lib/graphql/relay/relation_connection.rb

@@ -27,7 +27,7 @@ module GraphQL
         if first
           paged_nodes.length >= first && sliced_nodes_count > first
         elsif GraphQL::Relay::ConnectionType.bidirectional_pagination && last
-          sliced_nodes_count > last
+          sliced_nodes_count >= last
         else
           false
         end

data/lib/graphql/schema.rb

@@ -80,6 +80,7 @@ module GraphQL
       :orphan_types, :directives,
       :query_analyzers, :multiplex_analyzers, :instrumenters, :lazy_methods,
       :cursor_encoder,
+      :ast_node,
       :raise_definition_error
 
     # Single, long-lived instance of the provided subscriptions class, if there is one.

data/lib/graphql/schema/build_from_definition.rb

@@ -107,6 +107,8 @@ module GraphQL
             directives directives.values
           end
 
+          schema.ast_node = schema_definition if schema_definition
+
           schema
         end
 
@@ -117,18 +119,26 @@ module GraphQL
         NullScalarCoerce = ->(val, _ctx) { val }
 
         def build_enum_type(enum_type_definition, type_resolver)
-          GraphQL::EnumType.define(
+          enum = GraphQL::EnumType.define(
             name: enum_type_definition.name,
             description: enum_type_definition.description,
             values: enum_type_definition.values.map do |enum_value_definition|
-              EnumType::EnumValue.define(
+              value = EnumType::EnumValue.define(
                 name: enum_value_definition.name,
                 value: enum_value_definition.name,
                 deprecation_reason: build_deprecation_reason(enum_value_definition.directives),
                 description: enum_value_definition.description,
               )
+
+              value.ast_node = enum_value_definition
+
+              value
             end
           )
+
+          enum.ast_node = enum_type_definition
+
+          enum
         end
 
         def build_deprecation_reason(directives)
@@ -148,6 +158,8 @@ module GraphQL
             coerce: NullScalarCoerce,
           )
 
+          scalar_type.ast_node = scalar_type_definition
+
           if default_resolve.respond_to?(:coerce_input)
             scalar_type = scalar_type.redefine(
               coerce_input: ->(val, ctx) { default_resolve.coerce_input(scalar_type, val, ctx) },
@@ -159,11 +171,15 @@ module GraphQL
         end
 
         def build_union_type(union_type_definition, type_resolver)
-          GraphQL::UnionType.define(
+          union = GraphQL::UnionType.define(
             name: union_type_definition.name,
             description: union_type_definition.description,
             possible_types: union_type_definition.types.map{ |type_name| type_resolver.call(type_name) },
           )
+
+          union.ast_node = union_type_definition
+
+          union
         end
 
         def build_object_type(object_type_definition, type_resolver, default_resolve:)
@@ -175,14 +191,20 @@ module GraphQL
             fields: Hash[build_fields(object_type_definition.fields, type_resolver, default_resolve: typed_resolve_fn)],
             interfaces: object_type_definition.interfaces.map{ |interface_name| type_resolver.call(interface_name) },
           )
+          type_def.ast_node = object_type_definition
+          type_def
         end
 
         def build_input_object_type(input_object_type_definition, type_resolver)
-          GraphQL::InputObjectType.define(
+          input = GraphQL::InputObjectType.define(
             name: input_object_type_definition.name,
             description: input_object_type_definition.description,
             arguments: Hash[build_input_arguments(input_object_type_definition, type_resolver)],
           )
+
+          input.ast_node = input_object_type_definition
+
+          input
         end
 
         def build_default_value(default_value)
@@ -208,25 +230,33 @@ module GraphQL
               kwargs[:default_value] = build_default_value(input_argument.default_value)
             end
 
+            argument = GraphQL::Argument.define(
+              name: input_argument.name,
+              type: type_resolver.call(input_argument.type),
+              description: input_argument.description,
+              **kwargs,
+            )
+
+            argument.ast_node = input_object_type_definition
+
             [
               input_argument.name,
-              GraphQL::Argument.define(
-                name: input_argument.name,
-                type: type_resolver.call(input_argument.type),
-                description: input_argument.description,
-                **kwargs,
-              )
+              argument
             ]
           end
         end
 
         def build_directive(directive_definition, type_resolver)
-          GraphQL::Directive.define(
+          directive = GraphQL::Directive.define(
             name: directive_definition.name,
             description: directive_definition.description,
             arguments: Hash[build_directive_arguments(directive_definition, type_resolver)],
             locations: directive_definition.locations.map(&:to_sym),
           )
+
+          directive.ast_node = directive_definition
+
+          directive
         end
 
         def build_directive_arguments(directive_definition, type_resolver)
@@ -237,24 +267,32 @@ module GraphQL
               kwargs[:default_value] = build_default_value(directive_argument.default_value)
             end
 
+            argument = GraphQL::Argument.define(
+              name: directive_argument.name,
+              type: type_resolver.call(directive_argument.type),
+              description: directive_argument.description,
+              **kwargs,
+            )
+
+            argument.ast_node = directive_argument
+
             [
               directive_argument.name,
-              GraphQL::Argument.define(
-                name: directive_argument.name,
-                type: type_resolver.call(directive_argument.type),
-                description: directive_argument.description,
-                **kwargs,
-              )
+              argument
             ]
           end
         end
 
         def build_interface_type(interface_type_definition, type_resolver)
-          GraphQL::InterfaceType.define(
+          interface = GraphQL::InterfaceType.define(
             name: interface_type_definition.name,
             description: interface_type_definition.description,
             fields: Hash[build_fields(interface_type_definition.fields, type_resolver, default_resolve: nil)],
           )
+
+          interface.ast_node = interface_type_definition
+
+          interface
         end
 
         def build_fields(field_definitions, type_resolver, default_resolve:)
@@ -273,6 +311,8 @@ module GraphQL
                 **kwargs,
               )
 
+              arg.ast_node = argument
+
               [argument.name, arg]
             end]
 
@@ -285,6 +325,8 @@ module GraphQL
               deprecation_reason: build_deprecation_reason(field_definition.directives),
             )
 
+            field.ast_node = field_definition
+
             type_name = resolve_type_name(field_definition.type)
             field.connection = type_name.end_with?("Connection")
             [field_definition.name, field]

data/lib/graphql/subscriptions/action_cable_subscriptions.rb

@@ -39,7 +39,7 @@ module GraphQL
     #       })
     #
     #       payload = {
-    #         result: result.subscription? ? nil : result.to_h,
+    #         result: result.subscription? ? {data: nil} : result.to_h,
     #         more: result.subscription?,
     #       }
     #

data/lib/graphql/unresolved_type_error.rb

@@ -26,8 +26,9 @@ module GraphQL
       @possible_types = possible_types
       message = "The value from \"#{field.name}\" on \"#{parent_type}\" could not be resolved to \"#{field.type}\". " \
         "(Received: `#{resolved_type.inspect}`, Expected: [#{possible_types.map(&:inspect).join(", ")}]) " \
-        "Make sure you have defined a `type_from_object` proc on your schema and that value `#{value.inspect}` " \
-        "gets resolved to a valid type."
+        "Make sure you have defined a `resolve_type` proc on your schema and that value `#{value.inspect}` " \
+        "gets resolved to a valid type. You may need to add your type to `orphan_types` if it implements an " \
+        "interface but isn't a return type of any other field."
       super(message)
     end
   end

data/lib/graphql/version.rb

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

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 "#dup" do
     let(:obj_type) {
       GraphQL::ObjectType.define 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/multiplex_spec.rb

@@ -176,7 +176,7 @@ describe GraphQL::Execution::Multiplex do
       assert_raises(GraphQL::Error) do
         InspectSchema.execute("{ raiseError }")
       end
-      unhandled_err_json = 'null'
+      unhandled_err_json = '{}'
       assert_equal unhandled_err_json, InspectQueryInstrumentation.last_json
     end
   end

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/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/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/query/serial_execution/value_resolution_spec.rb

@@ -88,7 +88,7 @@ describe GraphQL::Query::SerialExecution::ValueResolution do
         err = assert_raises(GraphQL::UnresolvedTypeError) { result }
         expected_message = "The value from \"resolvesToNilInterface\" on \"Query\" could not be resolved to \"SomeInterface\". " \
           "(Received: `nil`, Expected: [SomeObject]) " \
-          "Make sure you have defined a `type_from_object` proc on your schema and that value `1337` " \
+          "Make sure you have defined a `resolve_type` proc on your schema and that value `1337` " \
           "gets resolved to a valid type."
         assert_equal expected_message, err.message
       end
@@ -105,7 +105,7 @@ describe GraphQL::Query::SerialExecution::ValueResolution do
         err = assert_raises(GraphQL::UnresolvedTypeError) { result }
         expected_message = "The value from \"resolvesToWrongTypeInterface\" on \"Query\" could not be resolved to \"SomeInterface\". " \
           "(Received: `OtherObject`, Expected: [SomeObject]) " \
-          "Make sure you have defined a `type_from_object` proc on your schema and that value `:something` " \
+          "Make sure you have defined a `resolve_type` proc on your schema and that value `:something` " \
           "gets resolved to a valid type."
         assert_equal expected_message, err.message
       end