graphql 1.7.14 → 1.8.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 1cacc586788be6d1c7d8d721f94b13332f01da66caff8f25ebfcab17c0c579c8
-  data.tar.gz: 778cde880c6fed60de3ba35e5114031e5fe334bf730d4a58b285f1de3fa56156
+SHA1:
+  metadata.gz: 909c3eda6b9624635a5901ceddee57a8e714a96c
+  data.tar.gz: 7cc0f7c57d20b6979fba3156077e7989d55d6646
 SHA512:
-  metadata.gz: '0729de66b6906d811ae9dcecb835f65166787697189c6faf0738913910116696c65103d7354f5099f6c72dde95dc270bfcc307ac94f4aa2e18990a1604456839'
-  data.tar.gz: e463d0e0f9ab888982d8652bc1aec4409530a146e9183387103223e25043d4811a097be4d9ef566762685f2d8d416a1b767200d6d6392ace180f98d9c0d890e9
+  metadata.gz: d94639f25409ba6fb4504fd9cd5fba087e717c36f88ef6329202c3f286050927ca73d67bba12313368f0aa8080af408611184b6f7bb2a4f0e24a327a76e124e7
+  data.tar.gz: d84a84ad71225d052113c863b69ff25cb724fc97d31db680b8eee1befe7252ee94e50ff5b4cf23018fc8460c20dc80c60075dc00f42af5138c01f1f7342af9d3

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_path}.rb"
+        template "function.erb", "#{options[:directory]}/functions/#{file_name}.rb"
       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_path}.rb"
+        template "loader.erb", "#{options[:directory]}/loaders/#{file_name}.rb"
       end
     end
   end

data/lib/generators/graphql/mutation_generator.rb

@@ -27,12 +27,7 @@ module Graphql
       attr_reader :file_name, :mutation_name, :field_name
 
       def create_mutation_file
-        unless @behavior == :revoke
-          create_mutation_root_type
-        else
-          log :gsub, "#{options[:directory]}/types/mutation_type.rb"
-        end
-        
+        create_mutation_root_type
         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::<%= class_name %> < GraphQL::Function
+class Functions::<%= name %> < GraphQL::Function
   # Define `initialize` to store field-level options, eg
   #
-  #     field :myField, function: Functions::<%= class_name %>.new(type: MyType)
+  #     field :myField, function: Functions::<%= name %>.new(type: MyType)
   #
   # attr_reader :type
   # def initialize(type:)

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

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

data/lib/graphql.rb

@@ -116,3 +116,5 @@ require "graphql/filter"
 require "graphql/subscriptions"
 require "graphql/parse_error"
 require "graphql/backtrace"
+
+require "graphql/deprecated_dsl"

data/lib/graphql/argument.rb

@@ -37,7 +37,6 @@ 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)
 

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

@@ -15,8 +15,6 @@ module GraphQL
 
     ensure_defined(:name, :description, :introspection?, :default_scalar?)
 
-    attr_accessor :ast_node
-
     def initialize
       @introspection = false
       @default_scalar = false
@@ -32,11 +30,12 @@ module GraphQL
 
     # @return [String] the name of this type, must be unique within a Schema
     attr_accessor :name
-
-    def name=(name)
-      GraphQL::NameValidator.validate!(name)
-      @name = name
-    end
+    # Future-compatible alias
+    # @see {GraphQL::SchemaMember}
+    alias :graphql_name :name
+    # Future-compatible alias
+    # @see {GraphQL::SchemaMember}
+    alias :graphql_definition :itself
 
     # @return [String, nil] a description for this type
     attr_accessor :description
@@ -61,9 +60,12 @@ 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)
-      other.is_a?(GraphQL::BaseType) && self.name == other.name
+      if other.is_a?(GraphQL::BaseType)
+        self.to_s == other.to_s
+      else
+        super
+      end
     end
 
     # If this type is modifying an underlying type,
@@ -86,10 +88,6 @@ 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`.
@@ -172,13 +170,17 @@ 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
 

data/lib/graphql/compatibility/query_parser_specification.rb

@@ -67,10 +67,6 @@ module GraphQL
                   nullValue: null
                   nullValueInObject: {a: null, b: "b"}
                   nullValueInArray: ["a", null, "b"]
-                  blockString: """
-                  Hello,
-                    World
-                  """
                 )
               }
             |
@@ -104,9 +100,6 @@ 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
@@ -123,116 +116,6 @@ 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/compatibility/query_parser_specification/parse_error_specification.rb

@@ -56,20 +56,6 @@ 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/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,28 @@
+# 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
+    def self.activate
+      GraphQL::Schema::Member.extend(Methods)
+    end
+    module Methods
+      def !
+        to_non_null_type
+      end
+    end
+    refine GraphQL::Schema::Member.singleton_class do
+      include Methods
+    end
+  end
+end

data/lib/graphql/directive.rb

@@ -11,7 +11,6 @@ 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,7 +74,6 @@ 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
@@ -122,7 +121,7 @@ module GraphQL
       if enum_value
         enum_value.name
       else
-        raise(UnresolvedValueError, "Can't resolve enum #{name} for #{value.inspect}")
+        raise(UnresolvedValueError, "Can't resolve enum #{name} for #{value}")
       end
     end
 
@@ -138,7 +137,6 @@ 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)

data/lib/graphql/execution.rb

@@ -2,7 +2,6 @@
 require "graphql/execution/directive_checks"
 require "graphql/execution/execute"
 require "graphql/execution/flatten"
-require "graphql/execution/instrumentation"
 require "graphql/execution/lazy"
 require "graphql/execution/multiplex"
 require "graphql/execution/typecast"

data/lib/graphql/execution/multiplex.rb

@@ -60,12 +60,12 @@ module GraphQL
               if queries.length != 1
                 raise ArgumentError, "Multiplexing doesn't support custom execution strategies, run one query at a time instead"
               else
-                instrument_and_analyze(multiplex, max_complexity: max_complexity) do
+                with_instrumentation(multiplex, max_complexity: max_complexity) do
                   [run_one_legacy(schema, queries.first)]
                 end
               end
             else
-              instrument_and_analyze(multiplex, max_complexity: max_complexity) do
+              with_instrumentation(multiplex, max_complexity: max_complexity) do
                 run_as_multiplex(multiplex)
               end
             end
@@ -93,7 +93,7 @@ module GraphQL
           end
         rescue StandardError
           # Assign values here so that the query's `@executed` becomes true
-          queries.map { |q| q.result_values ||= {} }
+          queries.map { |q| q.result_values ||= nil }
           raise
         end
 
@@ -162,17 +162,34 @@ module GraphQL
         # Apply multiplex & query instrumentation to `queries`.
         #
         # It yields when the queries should be executed, then runs teardown.
-        def instrument_and_analyze(multiplex, max_complexity:)
-          GraphQL::Execution::Instrumentation.apply_instrumenters(multiplex) do
-            schema = multiplex.schema
-            multiplex_analyzers = schema.multiplex_analyzers
-            if max_complexity
-              multiplex_analyzers += [GraphQL::Analysis::MaxQueryComplexity.new(max_complexity)]
-            end
+        def with_instrumentation(multiplex, max_complexity:)
+          schema = multiplex.schema
+          queries = multiplex.queries
+          query_instrumenters = schema.instrumenters[:query]
+          multiplex_instrumenters = schema.instrumenters[:multiplex]
+
+          # First, run multiplex instrumentation, then query instrumentation for each query
+          multiplex_instrumenters.each { |i| i.before_multiplex(multiplex) }
+          queries.each do |query|
+            query_instrumenters.each { |i| i.before_query(query) }
+          end
+
+          multiplex_analyzers = schema.multiplex_analyzers
+          if max_complexity
+            multiplex_analyzers += [GraphQL::Analysis::MaxQueryComplexity.new(max_complexity)]
+          end
+
+          GraphQL::Analysis.analyze_multiplex(multiplex, multiplex_analyzers)
 
-            GraphQL::Analysis.analyze_multiplex(multiplex, multiplex_analyzers)
-            yield
+          # Let them be executed
+          yield
+        ensure
+          # Finally, run teardown instrumentation for each query + the multiplex
+          # Use `reverse_each` so instrumenters are treated like a stack
+          queries.each do |query|
+            query_instrumenters.reverse_each { |i| i.after_query(query) }
           end
+          multiplex_instrumenters.reverse_each { |i| i.after_multiplex(multiplex) }
         end
       end
     end