graphql 1.7.6 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4ee2881b8335c9299d2dd2b707810856bb34d956
-  data.tar.gz: d23544e543addd64583dbcf82280fc92454a515c
+  metadata.gz: f5283bf51e22ac60f8d9368d9cc19b8c6d038d8b
+  data.tar.gz: 147ec429661a6fbc1aaef685ba94c8a81d87910e
 SHA512:
-  metadata.gz: db14299e06ef27b4f177980705c4f70d6b1d2a6defef6efad0a0b15db493ee1501c820c6fd298a60bc5ffdaf817d50abe4e7c2c145278da5e1ac46866e0a3648
-  data.tar.gz: 4776fe2f611c0cb93778fbf6101dfb81a3f08244bce650dccfbc2c999886ac0aac3d26f06533c6722c2e6aceab371ef9aa419f8d9b192301f2674519d5f66848
+  metadata.gz: 06a2a8730fc1c13dc0a0d76a35b19e89dd40ad842e41618abb1b05a7f75b667eede56c106728e3e68bd531e36e29b28050b991319599b7952ac3285fb3f9be3c
+  data.tar.gz: 8231c7696681477decf92b0665f3e4249b308153338c8d7cf5102b7e95133b9ac7aa6156f3dddc026c4178ea9fcb25d7f181f752298d5cf38185141af653a471

data/lib/generators/graphql/function_generator.rb

@@ -11,7 +11,7 @@ module Graphql
       source_root File.expand_path('../templates', __FILE__)
 
       def create_function_file
-        template "function.erb", "#{options[:directory]}/functions/#{file_name}.rb"
+        template "function.erb", "#{options[:directory]}/functions/#{file_path}.rb"
       end
     end
   end

data/lib/generators/graphql/install_generator.rb

@@ -81,13 +81,6 @@ module Graphql
         type: :boolean,
         desc: "Preconfigure smaller stack for API only apps"
 
-
-      GRAPHIQL_ROUTE = <<-RUBY
-if Rails.env.development?
-    mount GraphiQL::Rails::Engine, at: "/graphiql", graphql_path: "/graphql"
-  end
-RUBY
-
       def create_folder_structure
         create_dir("#{options[:directory]}/types")
         template("schema.erb", schema_file_path)
@@ -115,7 +108,20 @@ RUBY
           # This is a little cheat just to get cleaner shell output:
           log :route, 'graphiql-rails'
           shell.mute do
-            route(GRAPHIQL_ROUTE)
+            # Rails 5.2 has better support for `route`?
+            if Rails::VERSION::STRING > "5.2"
+              route <<-RUBY
+if Rails.env.development?
+  mount GraphiQL::Rails::Engine, at: "/graphiql", graphql_path: "/graphql"
+end
+RUBY
+            else
+              route <<-RUBY
+if Rails.env.development?
+    mount GraphiQL::Rails::Engine, at: "/graphiql", graphql_path: "/graphql"
+  end
+RUBY
+            end
           end
         end
 

data/lib/generators/graphql/loader_generator.rb

@@ -13,7 +13,7 @@ module Graphql
       source_root File.expand_path('../templates', __FILE__)
 
       def create_loader_file
-        template "loader.erb", "#{options[:directory]}/loaders/#{file_name}.rb"
+        template "loader.erb", "#{options[:directory]}/loaders/#{file_path}.rb"
       end
     end
   end

data/lib/generators/graphql/mutation_generator.rb

@@ -27,7 +27,12 @@ module Graphql
       attr_reader :file_name, :mutation_name, :field_name
 
       def create_mutation_file
-        create_mutation_root_type
+        unless @behavior == :revoke
+          create_mutation_root_type
+        else
+          log :gsub, "#{options[:directory]}/types/mutation_type.rb"
+        end
+        
         template "mutation.erb", "#{options[:directory]}/mutations/#{file_name}.rb"
 
         sentinel = /name "Mutation"\s*\n/m

data/lib/generators/graphql/templates/function.erb

@@ -1,7 +1,7 @@
-class Functions::<%= name %> < GraphQL::Function
+class Functions::<%= class_name %> < GraphQL::Function
   # Define `initialize` to store field-level options, eg
   #
-  #     field :myField, function: Functions::<%= name %>.new(type: MyType)
+  #     field :myField, function: Functions::<%= class_name %>.new(type: MyType)
   #
   # attr_reader :type
   # def initialize(type:)

data/lib/generators/graphql/templates/loader.erb

@@ -1,7 +1,7 @@
-class Loaders::<%= name %> < GraphQL::Batch::Loader
+class Loaders::<%= class_name %> < GraphQL::Batch::Loader
   # Define `initialize` to store grouping arguments, eg
   #
-  #     Loaders::<%= name %>.for(group).load(value)
+  #     Loaders::<%= class_name %>.for(group).load(value)
   #
   # def initialize()
   # end

data/lib/generators/graphql/templates/schema.erb

@@ -21,7 +21,7 @@
   }
 
   # Object Resolution
-  resolve_type -> (obj, ctx) {
+  resolve_type -> (type, obj, ctx) {
     # TODO: Implement this function
     # to return the correct type for `obj`
     raise(NotImplementedError)

data/lib/graphql/argument.rb

@@ -37,6 +37,7 @@ module GraphQL
     include GraphQL::Define::InstanceDefinable
     accepts_definitions :name, :type, :description, :default_value, :as, :prepare
     attr_accessor :type, :description, :default_value, :name, :as
+    attr_accessor :ast_node
 
     ensure_defined(:name, :description, :default_value, :type=, :type, :as, :expose_as, :prepare)
 
@@ -58,8 +59,13 @@ module GraphQL
     end
 
     def default_value=(new_default_value)
-      @has_default_value = true
-      @default_value = new_default_value
+      if new_default_value == NO_DEFAULT_VALUE
+        @has_default_value = false
+        @default_value = nil
+      else
+        @has_default_value = true
+        @default_value = new_default_value
+      end
     end
 
     # @!attribute name
@@ -97,28 +103,28 @@ module GraphQL
     NO_DEFAULT_VALUE = Object.new
     # @api private
     def self.from_dsl(name, type_or_argument = nil, description = nil, default_value: NO_DEFAULT_VALUE, as: nil, prepare: DefaultPrepare, **kwargs, &block)
-      if type_or_argument.is_a?(GraphQL::Argument)
-        return type_or_argument.redefine(name: name.to_s)
-      end
+      name_s = name.to_s
 
-      argument = if block_given?
-        GraphQL::Argument.define(&block)
-      else
-        GraphQL::Argument.define(**kwargs)
-      end
+      # Move some positional args into keywords if they're present
+      description && kwargs[:description] ||= description
+      kwargs[:name] ||= name_s
+      kwargs[:default_value] ||= default_value
+      kwargs[:as] ||= as
 
-      argument.name = name.to_s
-      type_or_argument && argument.type = type_or_argument
-      description && argument.description = description
-      if default_value != NO_DEFAULT_VALUE
-        argument.default_value = default_value
+      unless prepare == DefaultPrepare
+        kwargs[:prepare] ||= prepare
       end
-      as && argument.as = as
-      if prepare != DefaultPrepare
-        argument.prepare = prepare
+
+      if !type_or_argument.nil? && !type_or_argument.is_a?(GraphQL::Argument)
+        # Maybe a string, proc or BaseType
+        kwargs[:type] = type_or_argument
       end
 
-      argument
+      if type_or_argument.is_a?(GraphQL::Argument)
+        type_or_argument.redefine(kwargs, &block)
+      else
+        GraphQL::Argument.define(kwargs, &block)
+      end
     end
   end
 end

data/lib/graphql/backtrace/tracer.rb

@@ -22,30 +22,24 @@ module GraphQL
         end
 
         if push_data
-          execution_context = Thread.current[:graphql_execution_context] ||= []
-          if key == "execute_multiplex"
-            execution_context.clear
-            execution_context.push(push_data)
-            begin
-              yield
-            rescue StandardError => err
-              # This is an unhandled error from execution,
-              # Re-raise it with a GraphQL trace.
-              potential_context = execution_context.last
+          Thread.current[:last_graphql_backtrace_context] = push_data
+        end
+
+        if key == "execute_multiplex"
+          begin
+            yield
+          rescue StandardError => err
+            # This is an unhandled error from execution,
+            # Re-raise it with a GraphQL trace.
+            potential_context = Thread.current[:last_graphql_backtrace_context]
 
-              if potential_context.is_a?(GraphQL::Query::Context) || potential_context.is_a?(GraphQL::Query::Context::FieldResolutionContext)
-                raise TracedError.new(err, potential_context)
-              else
-                raise
-              end
-            ensure
-              execution_context.clear
+            if potential_context.is_a?(GraphQL::Query::Context) || potential_context.is_a?(GraphQL::Query::Context::FieldResolutionContext)
+              raise TracedError.new(err, potential_context)
+            else
+              raise
             end
-          else
-            execution_context.push(push_data)
-            res = yield
-            execution_context.pop
-            res
+          ensure
+            Thread.current[:last_graphql_backtrace_context] = nil
           end
         else
           yield

data/lib/graphql/backtrace.rb

@@ -19,7 +19,7 @@ module GraphQL
   #
   class Backtrace
     include Enumerable
-    extend GraphQL::Delegate
+    extend Forwardable
 
     def_delegators :to_a, :each, :[]
 

data/lib/graphql/backwards_compatibility.rb

@@ -12,11 +12,10 @@ module GraphQL
     # If `last`, then use the last arguments to call the function.
     def wrap_arity(callable, from:, to:, name:, last: false)
       arity = get_arity(callable)
-      case arity
-      when to
+      if arity == to || arity < 0
         # It already matches, return it as is
         callable
-      when from
+      elsif arity == from
         # It has the old arity, so wrap it with an arity converter
         message ="#{name} with #{from} arguments is deprecated, it now accepts #{to} arguments, see:"
         backtrace = caller(0, 20)

data/lib/graphql/base_type.rb

@@ -1,9 +1,13 @@
 # frozen_string_literal: true
+require "graphql/relay/type_extensions"
+
 module GraphQL
   # The parent for all type classes.
   class BaseType
     include GraphQL::Define::NonNullWithBang
     include GraphQL::Define::InstanceDefinable
+    include GraphQL::Relay::TypeExtensions
+
     accepts_definitions :name, :description,
         :introspection,
         :default_scalar,
@@ -13,7 +17,9 @@ module GraphQL
           global_id_field: GraphQL::Define::AssignGlobalIdField,
         }
 
-    ensure_defined(:name, :description, :introspection?, :default_scalar?)
+    ensure_defined(:graphql_name, :name, :description, :introspection?, :default_scalar?)
+
+    attr_accessor :ast_node
 
     def initialize
       @introspection = false
@@ -30,6 +36,17 @@ module GraphQL
 
     # @return [String] the name of this type, must be unique within a Schema
     attr_accessor :name
+    # Future-compatible alias
+    # @see {GraphQL::SchemaMember}
+    alias :graphql_name :name
+    # Future-compatible alias
+    # @see {GraphQL::SchemaMember}
+    alias :graphql_definition :itself
+
+    def name=(name)
+      GraphQL::NameValidator.validate!(name)
+      @name = name
+    end
 
     # @return [String, nil] a description for this type
     attr_accessor :description
@@ -54,12 +71,9 @@ module GraphQL
 
     # @param other [GraphQL::BaseType] compare to this object
     # @return [Boolean] are these types equivalent? (incl. non-null, list)
+    # @see {ModifiesAnotherType#==} for override on List & NonNull types
     def ==(other)
-      if other.is_a?(GraphQL::BaseType)
-        self.to_s == other.to_s
-      else
-        super
-      end
+      other.is_a?(GraphQL::BaseType) && self.name == other.name
     end
 
     # If this type is modifying an underlying type,
@@ -82,6 +96,10 @@ module GraphQL
       def unwrap
         self.of_type.unwrap
       end
+
+      def ==(other)
+        other.is_a?(ModifiesAnotherType) && other.of_type == of_type
+      end
     end
 
     # Find out which possible type to use for `value`.
@@ -164,38 +182,20 @@ module GraphQL
     def self.resolve_related_type(type_arg)
       case type_arg
       when Proc
-        # lazy-eval it
-        type_arg.call
+        # lazy-eval it, then try again
+        resolve_related_type(type_arg.call)
       when String
         # Get a constant by this name
         Object.const_get(type_arg)
       else
-        type_arg
+        if type_arg.respond_to?(:graphql_definition)
+          type_arg.graphql_definition
+        else
+          type_arg
+        end
       end
     end
 
-    # @return [GraphQL::ObjectType] The default connection type for this object type
-    def connection_type
-      @connection_type ||= define_connection
-    end
-
-    # Define a custom connection type for this object type
-    # @return [GraphQL::ObjectType]
-    def define_connection(**kwargs, &block)
-      GraphQL::Relay::ConnectionType.create_type(self, **kwargs, &block)
-    end
-
-    # @return [GraphQL::ObjectType] The default edge type for this object type
-    def edge_type
-      @edge_type ||= define_edge
-    end
-
-    # Define a custom edge type for this object type
-    # @return [GraphQL::ObjectType]
-    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]

data/lib/graphql/compatibility/query_parser_specification/parse_error_specification.rb

@@ -56,6 +56,20 @@ module GraphQL
           assert_raises_parse_error(%|{ field(arg:"\\uXXXF") }|)
         end
 
+        def test_it_rejects_empty_inline_fragments
+          assert_raises_parse_error("
+            query {
+              viewer {
+                login {
+                  ... on String {
+
+                  }
+                }
+              }
+            }
+          ")
+        end
+
         def assert_empty_document(query_string)
           doc = parse(query_string)
           assert_equal 0, doc.definitions.length

data/lib/graphql/compatibility/query_parser_specification.rb

@@ -67,6 +67,10 @@ module GraphQL
                   nullValue: null
                   nullValueInObject: {a: null, b: "b"}
                   nullValueInArray: ["a", null, "b"]
+                  blockString: """
+                  Hello,
+                    World
+                  """
                 )
               }
             |
@@ -100,6 +104,9 @@ module GraphQL
             assert_equal 'a', values[0]
             assert_instance_of GraphQL::Language::Nodes::NullValue, values[1]
             assert_equal 'b', values[2]
+
+            block_str_value = inputs[12].value
+            assert_equal "Hello,\n  World", block_str_value
           end
 
           def test_it_doesnt_parse_nonsense_variables
@@ -116,6 +123,116 @@ module GraphQL
             end
             assert_equal [1,26], [err_2.line, err_2.col]
           end
+
+          def test_enum_value_definitions_have_a_position
+            document = parse("""
+              enum Enum {
+                VALUE
+              }
+            """)
+
+            assert_equal [3, 17], document.definitions[0].values[0].position
+          end
+
+          def test_field_definitions_have_a_position
+            document = parse("""
+              type A {
+                field: String
+              }
+            """)
+
+            assert_equal [3, 17], document.definitions[0].fields[0].position
+          end
+
+          def test_input_value_definitions_have_a_position
+            document = parse("""
+              input A {
+                field: String
+              }
+            """)
+
+            assert_equal [3, 17], document.definitions[0].fields[0].position
+          end
+
+          def test_parses_when_there_are_no_interfaces
+            schema = "
+              type A {
+                a: String
+              }
+            "
+
+            document = parse(schema)
+
+            assert_equal [], document.definitions[0].interfaces.map(&:name)
+          end
+
+          def test_parses_implements_with_leading_ampersand
+            schema = "
+              type A implements & B {
+                a: String
+              }
+            "
+
+            document = parse(schema)
+
+            assert_equal ["B"], document.definitions[0].interfaces.map(&:name)
+            assert_equal [2, 35], document.definitions[0].interfaces[0].position
+          end
+
+          def test_parses_implements_with_leading_ampersand_and_multiple_interfaces
+            schema = "
+              type A implements & B & C {
+                a: String
+              }
+            "
+
+            document = parse(schema)
+
+            assert_equal ["B", "C"], document.definitions[0].interfaces.map(&:name)
+            assert_equal [2, 35], document.definitions[0].interfaces[0].position
+            assert_equal [2, 39], document.definitions[0].interfaces[1].position
+          end
+
+          def test_parses_implements_without_leading_ampersand
+            schema = "
+              type A implements B {
+                a: String
+              }
+            "
+
+            document = parse(schema)
+
+            assert_equal ["B"], document.definitions[0].interfaces.map(&:name)
+            assert_equal [2, 33], document.definitions[0].interfaces[0].position
+          end
+
+          def test_parses_implements_without_leading_ampersand_and_multiple_interfaces
+            schema = "
+              type A implements B & C {
+                a: String
+              }
+            "
+
+            document = parse(schema)
+
+            assert_equal ["B", "C"], document.definitions[0].interfaces.map(&:name)
+            assert_equal [2, 33], document.definitions[0].interfaces[0].position
+            assert_equal [2, 37], document.definitions[0].interfaces[1].position
+          end
+
+          def test_supports_old_syntax_for_parsing_multiple_interfaces
+            schema = "
+              type A implements B, C {
+                a: String
+              }
+            "
+
+            document = parse(schema)
+
+            assert_equal ["B", "C"], document.definitions[0].interfaces.map(&:name)
+            assert_equal [2, 33], document.definitions[0].interfaces[0].position
+            assert_equal [2, 36], document.definitions[0].interfaces[1].position
+          end
         end
       end
 

data/lib/graphql/define/assign_object_field.rb

@@ -18,23 +18,16 @@ module GraphQL
         base_field = if type_or_field.is_a?(GraphQL::Field)
           type_or_field.redefine(name: name_s)
         elsif function
-          GraphQL::Field.define(
-            arguments: function.arguments,
-            complexity: function.complexity,
-            name: name_s,
-            type: function.type,
-            resolve: function,
-            description: function.description,
-            function: function,
-            deprecation_reason: function.deprecation_reason,
-          )
+          func_field = GraphQL::Function.build_field(function)
+          func_field.name = name_s
+          func_field
         elsif field.is_a?(GraphQL::Field)
           field.redefine(name: name_s)
         else
           nil
         end
 
-        field = if base_field
+        obj_field = if base_field
           base_field.redefine(kwargs, &block)
         else
           GraphQL::Field.define(kwargs, &block)
@@ -42,7 +35,7 @@ module GraphQL
 
 
         # Attach the field to the type
-        owner_type.fields[name_s] = field
+        owner_type.fields[name_s] = obj_field
       end
     end
   end

data/lib/graphql/deprecated_dsl.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+module GraphQL
+  # There are two ways to apply the deprecated `!` DSL to class-style schema definitions:
+  #
+  # 1. Scoped by file (CRuby only), add to the top of the file:
+  #
+  #      using GraphQL::DeprecatedDSL
+  #
+  #   (This is a "refinement", there are also other ways to scope it.)
+  #
+  # 2. Global application, add before schema definition:
+  #
+  #      GraphQL::DeprecatedDSL.activate
+  #
+  module DeprecatedDSL
+    TYPE_CLASSES = [
+      GraphQL::Schema::Scalar,
+      GraphQL::Schema::Enum,
+      GraphQL::Schema::InputObject,
+      GraphQL::Schema::Union,
+      GraphQL::Schema::Interface,
+      GraphQL::Schema::Object,
+    ]
+
+    def self.activate
+      TYPE_CLASSES.each { |c| c.extend(Methods) }
+      GraphQL::Schema::List.include(Methods)
+      GraphQL::Schema::NonNull.include(Methods)
+    end
+    module Methods
+      def !
+        to_non_null_type
+      end
+    end
+
+    TYPE_CLASSES.each do |type_class|
+      refine type_class.singleton_class do
+        include Methods
+      end
+    end
+  end
+end

data/lib/graphql/directive.rb

@@ -11,6 +11,7 @@ module GraphQL
     accepts_definitions :locations, :name, :description, :arguments, :default_directive, argument: GraphQL::Define::AssignArgument
 
     attr_accessor :locations, :arguments, :name, :description, :arguments_class
+    attr_accessor :ast_node
     # @api private
     attr_writer :default_directive
     ensure_defined(:locations, :arguments, :name, :description, :default_directive?)

data/lib/graphql/enum_type.rb

@@ -74,6 +74,7 @@ module GraphQL
   class EnumType < GraphQL::BaseType
     accepts_definitions :values, value: GraphQL::Define::AssignEnumValue
     ensure_defined(:values, :validate_non_null_input, :coerce_non_null_input, :coerce_result)
+    attr_accessor :ast_node
 
     def initialize
       super
@@ -121,7 +122,7 @@ module GraphQL
       if enum_value
         enum_value.name
       else
-        raise(UnresolvedValueError, "Can't resolve enum #{name} for #{value}")
+        raise(UnresolvedValueError, "Can't resolve enum #{name} for #{value.inspect}")
       end
     end
 
@@ -137,6 +138,7 @@ module GraphQL
       ATTRIBUTES = [:name, :description, :deprecation_reason, :value]
       accepts_definitions(*ATTRIBUTES)
       attr_accessor(*ATTRIBUTES)
+      attr_accessor :ast_node
       ensure_defined(*ATTRIBUTES)
 
       def name=(new_name)