graphql 1.9.0.pre2 → 1.9.0.pre3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7576d86b005acda0b6db32b531eb5ee5994b46d5
-  data.tar.gz: 5d27e5a79e0b2ab1d8c64edd8aa4ed5bc66b72e8
+  metadata.gz: d574e6bf6c3c4644fd85e279ddf56ab3128bef2d
+  data.tar.gz: a6227d0ec2ee59131b2de45ccf87c2541279543d
 SHA512:
-  metadata.gz: 001ec87271eaefae504d24deac1c3b6d241f1b944b2297050e3d35a8a72c6a016ec9dd6a48f3c1bdef1ab5f9eb6aac2f5f31ca745bfdf9edb077abbc6f8158d7
-  data.tar.gz: fafac00586652e70e096f68a92dd20bcf712e09343d721638987f3ba8d69e77250fd25de5743ca521687c1a22a8df5355b4f7b84f500ff898446c29fe08e4bed
+  metadata.gz: 3d91a0736831fa204240513b2cff401bf51a8ffb09739662fd95415bf2a91f53f088dcbcb026ff883d43476980260d1ab222d6bd5c969060ce279e9badf7ecb5
+  data.tar.gz: 0eaa0115f08cae059cb4d514fc572cf064956dda38ac87919d841b72103aa67df7f871e761375704ade18b5e77c474c99e5e514dcb098608bba7b3e629a0241d

data/lib/graphql/execution/lookahead.rb

@@ -40,6 +40,7 @@ module GraphQL
         @field = field
         @root_type = root_type
         @query = query
+        @selected_type = @field ? @field.type.unwrap : root_type
       end
 
       # @return [Array<GraphQL::Language::Nodes::Field>]
@@ -72,16 +73,10 @@ module GraphQL
       # Like {#selects?}, but can be used for chaining.
       # It returns a null object (check with {#selected?})
       # @return [GraphQL::Execution::Lookahead]
-      def selection(field_name, arguments: nil)
+      def selection(field_name, selected_type: @selected_type, arguments: nil)
         next_field_name = normalize_name(field_name)
 
-        next_field_owner = if @field
-          @field.type.unwrap
-        else
-          @root_type
-        end
-
-        next_field_defn = FieldHelpers.get_field(@query.schema, next_field_owner, next_field_name)
+        next_field_defn = FieldHelpers.get_field(@query.schema, selected_type, next_field_name)
         if next_field_defn
           next_nodes = []
           @ast_nodes.each do |ast_node|
@@ -118,7 +113,7 @@ module GraphQL
       def selections(arguments: nil)
         subselections_by_name = {}
         @ast_nodes.each do |node|
-          find_selections(subselections_by_name, node.selections, arguments)
+          find_selections(subselections_by_name, @selected_type, node.selections, arguments)
         end
 
         # Items may be filtered out if `arguments` doesn't match
@@ -139,6 +134,10 @@ module GraphQL
         @field && @field.original_name
       end
 
+      def inspect
+        "#<GraphQL::Execution::Lookahead #{@field ? "@field=#{@field.path.inspect}": "@root_type=#{@root_type}"} @ast_nodes.size=#{@ast_nodes.size}>"
+      end
+
       # This is returned for {Lookahead#selection} when a non-existent field is passed
       class NullLookahead < Lookahead
         # No inputs required here.
@@ -160,6 +159,10 @@ module GraphQL
         def selections(*)
           []
         end
+
+        def inspect
+          "#<GraphQL::Execution::Lookahead::NullLookahead>"
+        end
       end
 
       # A singleton, so that misses don't come with overhead.
@@ -184,16 +187,22 @@ module GraphQL
         end
       end
 
-      def find_selections(subselections_by_name, ast_selections, arguments)
+      def find_selections(subselections_by_name, selected_type, ast_selections, arguments)
         ast_selections.each do |ast_selection|
           case ast_selection
           when GraphQL::Language::Nodes::Field
-            subselections_by_name[ast_selection.name] ||= selection(ast_selection.name, arguments: arguments)
+            subselections_by_name[ast_selection.name] ||= selection(ast_selection.name, selected_type: selected_type, arguments: arguments)
           when GraphQL::Language::Nodes::InlineFragment
-            find_selections(subselections_by_name, ast_selection.selections, arguments)
+            if (t = ast_selection.type)
+              # Assuming this is valid, that `t` will be found.
+              selected_type = @query.schema.types[t.name].metadata[:type_class]
+            end
+            find_selections(subselections_by_name, selected_type, ast_selection.selections, arguments)
           when GraphQL::Language::Nodes::FragmentSpread
             frag_defn = @query.fragments[ast_selection.name] || raise("Invariant: Can't look ahead to nonexistent fragment #{ast_selection.name} (found: #{@query.fragments.keys})")
-            find_selections(subselections_by_name, frag_defn.selections, arguments)
+            # Again, assuming a valid AST
+            selected_type = @query.schema.types[frag_defn.type.name].metadata[:type_class]
+            find_selections(subselections_by_name, selected_type, frag_defn.selections, arguments)
           else
             raise "Invariant: Unexpected selection type: #{ast_selection.class}"
           end

data/lib/graphql/language/visitor.rb

@@ -65,9 +65,16 @@ module GraphQL
       # Visit `document` and all children, applying hooks as you go
       # @return [void]
       def visit
-        @result, _nil_parent = on_node_with_modifications(@document, nil)
+        result = on_node_with_modifications(@document, nil)
+        @result = if result.is_a?(Array)
+          result.first
+        else
+          # The node wasn't modified
+          @document
+        end
       end
 
+      # Call the user-defined handler for `node`.
       def visit_node(node, parent)
         public_send(node.visit_method, node, parent)
       end
@@ -80,77 +87,81 @@ module GraphQL
       # For compatibility, it calls hook procs, too.
       # @param node [GraphQL::Language::Nodes::AbstractNode] the node being visited
       # @param parent [GraphQL::Language::Nodes::AbstractNode, nil] the previously-visited node, or `nil` if this is the root node.
-      # @return [void]
+      # @return [Array, nil] If there were modifications, it returns an array of new nodes, otherwise, it returns `nil`.
       def on_abstract_node(node, parent)
         if node == DELETE_NODE
           # This might be passed to `super(DELETE_NODE, ...)`
           # by a user hook, don't want to keep visiting in that case.
-          [node, parent]
+          nil
         else
           # Run hooks if there are any
-          begin_hooks_ok = @visitors.none? || begin_visit(node, parent)
+          new_node = node
+          begin_hooks_ok = @visitors.none? || begin_visit(new_node, parent)
           if begin_hooks_ok
             node.children.each do |child_node|
-              new_child_and_node = on_node_with_modifications(child_node, node)
+              new_child_and_node = on_node_with_modifications(child_node, new_node)
               # Reassign `node` in case the child hook makes a modification
               if new_child_and_node.is_a?(Array)
-                node = new_child_and_node[1]
+                new_node = new_child_and_node[1]
               end
             end
           end
-          @visitors.any? && end_visit(node, parent)
-          [node, parent]
+          @visitors.any? && end_visit(new_node, parent)
+
+          if new_node.equal?(node)
+            nil
+          else
+            [new_node, parent]
+          end
         end
       end
 
       # We don't use `alias` here because it breaks `super`
-      def self.make_visit_method(node_method, super_method)
-        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+      def self.make_visit_method(node_method)
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
           def #{node_method}(node, parent)
-            #{super_method}(node, parent)
+            child_mod = on_abstract_node(node, parent)
+            # If visiting the children returned changes, continue passing those.
+            child_mod || [node, parent]
           end
-        EOS
+        RUBY
       end
 
-      make_visit_method :on_argument, :on_abstract_node
-      make_visit_method :on_directive, :on_abstract_node
-      make_visit_method :on_directive_definition, :on_abstract_node
-      make_visit_method :on_directive_location, :on_abstract_node
-      make_visit_method :on_document, :on_abstract_node
-      make_visit_method :on_enum, :on_abstract_node
-      make_visit_method :on_enum_type_definition, :on_abstract_node
-      make_visit_method :on_enum_type_extension, :on_abstract_node
-      make_visit_method :on_enum_value_definition, :on_abstract_node
-      make_visit_method :on_field, :on_abstract_node
-      make_visit_method :on_field_definition, :on_abstract_node
-      make_visit_method :on_fragment_definition, :on_abstract_node
-      make_visit_method :on_fragment_spread, :on_abstract_node
-      make_visit_method :on_inline_fragment, :on_abstract_node
-      make_visit_method :on_input_object, :on_abstract_node
-      make_visit_method :on_input_object_type_definition, :on_abstract_node
-      make_visit_method :on_input_object_type_extension, :on_abstract_node
-      make_visit_method :on_input_value_definition, :on_abstract_node
-      make_visit_method :on_interface_type_definition, :on_abstract_node
-      make_visit_method :on_interface_type_extension, :on_abstract_node
-      make_visit_method :on_list_type, :on_abstract_node
-      make_visit_method :on_non_null_type, :on_abstract_node
-      make_visit_method :on_null_value, :on_abstract_node
-      make_visit_method :on_object_type_definition, :on_abstract_node
-      make_visit_method :on_object_type_extension, :on_abstract_node
-      make_visit_method :on_operation_definition, :on_abstract_node
-      make_visit_method :on_scalar_type_definition, :on_abstract_node
-      make_visit_method :on_scalar_type_extension, :on_abstract_node
-      make_visit_method :on_schema_definition, :on_abstract_node
-      make_visit_method :on_schema_extension, :on_abstract_node
-      make_visit_method :on_type_name, :on_abstract_node
-      make_visit_method :on_union_type_definition, :on_abstract_node
-      make_visit_method :on_union_type_extension, :on_abstract_node
-      make_visit_method :on_variable_definition, :on_abstract_node
-      make_visit_method :on_variable_identifier, :on_abstract_node
-
-      def visit_node(node, parent)
-        public_send(node.visit_method, node, parent)
-      end
+      make_visit_method :on_argument
+      make_visit_method :on_directive
+      make_visit_method :on_directive_definition
+      make_visit_method :on_directive_location
+      make_visit_method :on_document
+      make_visit_method :on_enum
+      make_visit_method :on_enum_type_definition
+      make_visit_method :on_enum_type_extension
+      make_visit_method :on_enum_value_definition
+      make_visit_method :on_field
+      make_visit_method :on_field_definition
+      make_visit_method :on_fragment_definition
+      make_visit_method :on_fragment_spread
+      make_visit_method :on_inline_fragment
+      make_visit_method :on_input_object
+      make_visit_method :on_input_object_type_definition
+      make_visit_method :on_input_object_type_extension
+      make_visit_method :on_input_value_definition
+      make_visit_method :on_interface_type_definition
+      make_visit_method :on_interface_type_extension
+      make_visit_method :on_list_type
+      make_visit_method :on_non_null_type
+      make_visit_method :on_null_value
+      make_visit_method :on_object_type_definition
+      make_visit_method :on_object_type_extension
+      make_visit_method :on_operation_definition
+      make_visit_method :on_scalar_type_definition
+      make_visit_method :on_scalar_type_extension
+      make_visit_method :on_schema_definition
+      make_visit_method :on_schema_extension
+      make_visit_method :on_type_name
+      make_visit_method :on_union_type_definition
+      make_visit_method :on_union_type_extension
+      make_visit_method :on_variable_definition
+      make_visit_method :on_variable_identifier
 
       private
 
@@ -177,7 +188,7 @@ module GraphQL
           # The user-provided hook didn't make any modifications.
           # In fact, the hook might have returned who-knows-what, so
           # ignore the return value and use the original values.
-          [node, parent]
+          new_node_and_new_parent
         end
       end
 

data/lib/graphql/query/variable_validation_error.rb

@@ -14,7 +14,16 @@ module GraphQL
       end
 
       def to_h
-        super.merge({ "value" => value, "problems" => validation_result.problems })
+        # It is possible there are other extension items in this error, so handle
+        # a one level deep merge explicitly. However beyond that only show the
+        # latest value and problems.
+        super.merge({ "extensions" => { "value" => value, "problems" => validation_result.problems }}) do |key, oldValue, newValue|
+          if oldValue.respond_to? merge
+            oldValue.merge(newValue)
+          else
+            newValue
+          end
+        end
       end
     end
   end

data/lib/graphql/schema.rb

@@ -42,6 +42,7 @@ require "graphql/schema/directive/transform"
 require "graphql/schema/resolver"
 require "graphql/schema/mutation"
 require "graphql/schema/relay_classic_mutation"
+require "graphql/schema/subscription"
 
 module GraphQL
   # A GraphQL schema which may be queried with {GraphQL::Query}.
@@ -184,7 +185,7 @@ module GraphQL
       @introspection_namespace = nil
       @introspection_system = nil
       @interpeter = false
-      @error_bubbling = true
+      @error_bubbling = false
     end
 
     # @return [Boolean] True if using the new {GraphQL::Execution::Interpreter}
@@ -915,11 +916,15 @@ module GraphQL
       end
 
       def resolve_type(type, obj, ctx)
-        raise NotImplementedError, "#{self.name}.resolve_type(type, obj, ctx) must be implemented to use Union types or Interface types (tried to resolve: #{type.name})"
+        if type.kind.object?
+          type
+        else
+          raise NotImplementedError, "#{self.name}.resolve_type(type, obj, ctx) must be implemented to use Union types or Interface types (tried to resolve: #{type.name})"
+        end
       end
 
       def object_from_id(node_id, ctx)
-        raise NotImplementedError, "#{self.name}.object_from_id(node_id, ctx) must be implemented to use the `node` field (tried to load from id `#{node_id}`)"
+        raise NotImplementedError, "#{self.name}.object_from_id(node_id, ctx) must be implemented to load by ID (tried to load from id `#{node_id}`)"
       end
 
       def id_from_object(object, type, ctx)

data/lib/graphql/schema/field.rb

@@ -59,10 +59,11 @@ module GraphQL
       # It also normalizes positional arguments into keywords for {Schema::Field#initialize}.
       # @param resolver [Class] A {GraphQL::Schema::Resolver} class to use for field configuration
       # @param mutation [Class] A {GraphQL::Schema::Mutation} class to use for field configuration
+      # @param subscription [Class] A {GraphQL::Schema::Subscription} class to use for field configuration
       # @return [GraphQL::Schema:Field] an instance of `self
       # @see {.initialize} for other options
-      def self.from_options(name = nil, type = nil, desc = nil, resolver: nil, mutation: nil, **kwargs, &block)
-        if (parent_config = resolver || mutation)
+      def self.from_options(name = nil, type = nil, desc = nil, resolver: nil, mutation: nil, subscription: nil,**kwargs, &block)
+        if (parent_config = resolver || mutation || subscription)
           # Get the parent config, merge in local overrides
           kwargs = parent_config.field_options.merge(kwargs)
           # Add a reference to that parent class

data/lib/graphql/schema/mutation.rb

@@ -60,6 +60,7 @@ module GraphQL
     #
     class Mutation < GraphQL::Schema::Resolver
       extend GraphQL::Schema::Member::HasFields
+      extend GraphQL::Schema::Resolver::HasPayloadType
 
       class << self
         # Override this method to handle legacy-style usages of `MyMutation.field`
@@ -71,62 +72,17 @@ module GraphQL
           end
         end
 
-        # Call this method to get the derived return type of the mutation,
-        # or use it as a configuration method to assign a return type
-        # instead of generating one.
-        # @param new_payload_type [Class, nil] If a type definition class is provided, it will be used as the return type of the mutation field
-        # @return [Class] The object type which this mutation returns.
-        def payload_type(new_payload_type = nil)
-          if new_payload_type
-            @payload_type = new_payload_type
-          end
-          @payload_type ||= generate_payload_type
-        end
-
-        alias :type :payload_type
-        alias :type_expr :payload_type
-
-        def field_class(new_class = nil)
-          if new_class
-            @field_class = new_class
-          else
-            @field_class || find_inherited_method(:field_class, GraphQL::Schema::Field)
-          end
-        end
-
-        # An object class to use for deriving return types
-        # @param new_class [Class, nil] Defaults to {GraphQL::Schema::Object}
-        # @return [Class]
-        def object_class(new_class = nil)
-          if new_class
-            @object_class = new_class
-          end
-          @object_class || (superclass.respond_to?(:object_class) ? superclass.object_class : GraphQL::Schema::Object)
-        end
-
         def visible?(context)
           true
         end
 
         private
 
-        # Build a subclass of {.object_class} based on `self`.
-        # This value will be cached as `{.payload_type}`.
-        # Override this hook to customize return type generation.
+        # Override this to attach self as `mutation`
         def generate_payload_type
-          mutation_name = graphql_name
-          mutation_fields = fields
-          mutation_class = self
-          Class.new(object_class) do
-            graphql_name("#{mutation_name}Payload")
-            description("Autogenerated return type of #{mutation_name}")
-            mutation(mutation_class)
-            mutation_fields.each do |name, f|
-              # Reattach the already-defined field here
-              # (The field's `.owner` will still point to the mutation, not the object type, I think)
-              add_field(f)
-            end
-          end
+          payload_class = super
+          payload_class.mutation(self)
+          payload_class
         end
       end
     end

data/lib/graphql/schema/resolver.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require "graphql/schema/resolver/has_payload_type"
 
 module GraphQL
   class Schema

data/lib/graphql/schema/resolver/has_payload_type.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Resolver
+      # Adds `field(...)` helper to resolvers so that they can
+      # generate payload types.
+      #
+      # Or, an already-defined one can be attached with `payload_type(...)`.
+      module HasPayloadType
+        # Call this method to get the derived return type of the mutation,
+        # or use it as a configuration method to assign a return type
+        # instead of generating one.
+        # @param new_payload_type [Class, nil] If a type definition class is provided, it will be used as the return type of the mutation field
+        # @return [Class] The object type which this mutation returns.
+        def payload_type(new_payload_type = nil)
+          if new_payload_type
+            @payload_type = new_payload_type
+          end
+          @payload_type ||= generate_payload_type
+        end
+
+        alias :type :payload_type
+        alias :type_expr :payload_type
+
+        def field_class(new_class = nil)
+          if new_class
+            @field_class = new_class
+          else
+            @field_class || find_inherited_method(:field_class, GraphQL::Schema::Field)
+          end
+        end
+
+        # An object class to use for deriving return types
+        # @param new_class [Class, nil] Defaults to {GraphQL::Schema::Object}
+        # @return [Class]
+        def object_class(new_class = nil)
+          if new_class
+            @object_class = new_class
+          end
+          @object_class || (superclass.respond_to?(:object_class) ? superclass.object_class : GraphQL::Schema::Object)
+        end
+
+        private
+
+        # Build a subclass of {.object_class} based on `self`.
+        # This value will be cached as `{.payload_type}`.
+        # Override this hook to customize return type generation.
+        def generate_payload_type
+          resolver_name = graphql_name
+          resolver_fields = fields
+          Class.new(object_class) do
+            graphql_name("#{resolver_name}Payload")
+            description("Autogenerated return type of #{resolver_name}")
+            resolver_fields.each do |name, f|
+              # Reattach the already-defined field here
+              # (The field's `.owner` will still point to the mutation, not the object type, I think)
+              add_field(f)
+            end
+          end
+        end
+      end
+    end
+  end
+end