graphql 1.9.0 → 2.1.1

data/lib/graphql/language/visitor.rb

@@ -7,7 +7,7 @@ module GraphQL
     #   class NameCounter < GraphQL::Language::Visitor
     #     def initialize(document, field_name)
     #       super(document)
-    #       @field_name
+    #       @field_name = field_name
     #       @count = 0
     #     end
     #
@@ -16,7 +16,7 @@ module GraphQL
     #     def on_field(node, parent)
     #       # if this field matches our search, increment the counter
     #       if node.name == @field_name
-    #         @count = 0
+    #         @count += 1
     #       end
     #       # Continue visiting subfields:
     #       super
@@ -24,18 +24,15 @@ module GraphQL
     #   end
     #
     #   # Initialize a visitor
-    #   visitor = GraphQL::Language::Visitor.new(document, "name")
+    #   visitor = NameCounter.new(document, "name")
     #   # Run it
     #   visitor.visit
     #   # Check the result
     #   visitor.count
     #   # => 3
+    #
+    # @see GraphQL::Language::StaticVisitor for a faster visitor that doesn't support modifying the document
     class Visitor
-      # If any hook returns this value, the {Visitor} stops visiting this
-      # node right away
-      # @deprecated Use `super` to continue the visit; or don't call it to halt.
-      SKIP = :_skip
-
       class DeleteNode; end
 
       # When this is returned from a visitor method,
@@ -44,28 +41,18 @@ module GraphQL
 
       def initialize(document)
         @document = document
-        @visitors = {}
         @result = nil
       end
 
       # @return [GraphQL::Language::Nodes::Document] The document with any modifications applied
       attr_reader :result
 
-      # Get a {NodeVisitor} for `node_class`
-      # @param node_class [Class] The node class that you want to listen to
-      # @return [NodeVisitor]
-      #
-      # @example Run a hook whenever you enter a new Field
-      #   visitor[GraphQL::Language::Nodes::Field] << ->(node, parent) { p "Here's a field" }
-      # @deprecated see `on_` methods, like {#on_field}
-      def [](node_class)
-        @visitors[node_class] ||= NodeVisitor.new
-      end
-
-      # Visit `document` and all children, applying hooks as you go
+      # Visit `document` and all children
       # @return [void]
       def visit
-        result = on_node_with_modifications(@document, nil)
+        # `@document` may be any kind of node:
+        visit_method = :"#{@document.visit_method}_with_modifications"
+        result = public_send(visit_method, @document, nil)
         @result = if result.is_a?(Array)
           result.first
         else
@@ -74,102 +61,204 @@ module GraphQL
         end
       end
 
-      # Call the user-defined handler for `node`.
-      def visit_node(node, parent)
-        public_send(node.visit_method, node, parent)
-      end
+      # We don't use `alias` here because it breaks `super`
+      def self.make_visit_methods(ast_node_class)
+        node_method = ast_node_class.visit_method
+        children_of_type = ast_node_class.children_of_type
+        child_visit_method = :"#{node_method}_children"
 
-      # The default implementation for visiting an AST node.
-      # It doesn't _do_ anything, but it continues to visiting the node's children.
-      # To customize this hook, override one of its make_visit_methodes (or the base method?)
-      # in your subclasses.
-      #
-      # 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 [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.
-          nil
-        else
-          # Run hooks if there are any
-          new_node = node
-          begin_hooks_ok = @visitors.empty? || 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, new_node)
-              # Reassign `node` in case the child hook makes a modification
-              if new_child_and_node.is_a?(Array)
-                new_node = new_child_and_node[1]
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          # The default implementation for visiting an AST node.
+          # It doesn't _do_ anything, but it continues to visiting the node's children.
+          # To customize this hook, override one of its make_visit_methods (or the base method?)
+          # in your subclasses.
+          #
+          # @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 [Array, nil] If there were modifications, it returns an array of new nodes, otherwise, it returns `nil`.
+          def #{node_method}(node, parent)
+            if node.equal?(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]
+            else
+              new_node = node
+              #{
+                if method_defined?(child_visit_method)
+                  "new_node = #{child_visit_method}(new_node)"
+                elsif children_of_type
+                  children_of_type.map do |child_accessor, child_class|
+                    "node.#{child_accessor}.each do |child_node|
+                      new_child_and_node = #{child_class.visit_method}_with_modifications(child_node, new_node)
+                      # Reassign `node` in case the child hook makes a modification
+                      if new_child_and_node.is_a?(Array)
+                        new_node = new_child_and_node[1]
+                      end
+                    end"
+                  end.join("\n")
+                else
+                  ""
+                end
+              }
+
+              if new_node.equal?(node)
+                [node, parent]
+              else
+                [new_node, parent]
               end
             end
           end
-          @visitors.any? && end_visit(new_node, parent)
 
-          if new_node.equal?(node)
-            nil
+          def #{node_method}_with_modifications(node, parent)
+            new_node_and_new_parent = #{node_method}(node, parent)
+            apply_modifications(node, parent, new_node_and_new_parent)
+          end
+        RUBY
+      end
+
+      def on_document_children(document_node)
+        new_node = document_node
+        document_node.children.each do |child_node|
+          visit_method = :"#{child_node.visit_method}_with_modifications"
+          new_child_and_node = public_send(visit_method, child_node, new_node)
+          # Reassign `node` in case the child hook makes a modification
+          if new_child_and_node.is_a?(Array)
+            new_node = new_child_and_node[1]
+          end
+        end
+        new_node
+      end
+
+      def on_field_children(new_node)
+        new_node.arguments.each do |arg_node| # rubocop:disable Development/ContextIsPassedCop
+          new_child_and_node = on_argument_with_modifications(arg_node, new_node)
+          # Reassign `node` in case the child hook makes a modification
+          if new_child_and_node.is_a?(Array)
+            new_node = new_child_and_node[1]
+          end
+        end
+        new_node = visit_directives(new_node)
+        new_node = visit_selections(new_node)
+        new_node
+      end
+
+      def visit_directives(new_node)
+        new_node.directives.each do |dir_node|
+          new_child_and_node = on_directive_with_modifications(dir_node, new_node)
+          # Reassign `node` in case the child hook makes a modification
+          if new_child_and_node.is_a?(Array)
+            new_node = new_child_and_node[1]
+          end
+        end
+        new_node
+      end
+
+      def visit_selections(new_node)
+        new_node.selections.each do |selection|
+          new_child_and_node = case selection
+          when GraphQL::Language::Nodes::Field
+            on_field_with_modifications(selection, new_node)
+          when GraphQL::Language::Nodes::InlineFragment
+            on_inline_fragment_with_modifications(selection, new_node)
+          when GraphQL::Language::Nodes::FragmentSpread
+            on_fragment_spread_with_modifications(selection, new_node)
           else
-            [new_node, parent]
+            raise ArgumentError, "Invariant: unexpected field selection #{selection.class} (#{selection.inspect})"
+          end
+          # Reassign `node` in case the child hook makes a modification
+          if new_child_and_node.is_a?(Array)
+            new_node = new_child_and_node[1]
           end
         end
+        new_node
       end
 
-      # We don't use `alias` here because it breaks `super`
-      def self.make_visit_method(node_method)
-        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-          def #{node_method}(node, parent)
-            child_mod = on_abstract_node(node, parent)
-            # If visiting the children returned changes, continue passing those.
-            child_mod || [node, parent]
+      def on_fragment_definition_children(new_node)
+        new_node = visit_directives(new_node)
+        new_node = visit_selections(new_node)
+        new_node
+      end
+
+      alias :on_inline_fragment_children :on_fragment_definition_children
+
+      def on_operation_definition_children(new_node)
+        new_node.variables.each do |arg_node|
+          new_child_and_node = on_variable_definition_with_modifications(arg_node, new_node)
+          # Reassign `node` in case the child hook makes a modification
+          if new_child_and_node.is_a?(Array)
+            new_node = new_child_and_node[1]
           end
-        RUBY
+        end
+        new_node = visit_directives(new_node)
+        new_node = visit_selections(new_node)
+        new_node
       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
+      def on_argument_children(new_node)
+        new_node.children.each do |value_node|
+          new_child_and_node = case value_node
+          when Language::Nodes::VariableIdentifier
+            on_variable_identifier_with_modifications(value_node, new_node)
+          when Language::Nodes::InputObject
+            on_input_object_with_modifications(value_node, new_node)
+          when Language::Nodes::Enum
+            on_enum_with_modifications(value_node, new_node)
+          when Language::Nodes::NullValue
+            on_null_value_with_modifications(value_node, new_node)
+          else
+            raise ArgumentError, "Invariant: unexpected argument value node #{value_node.class} (#{value_node.inspect})"
+          end
+          # Reassign `node` in case the child hook makes a modification
+          if new_child_and_node.is_a?(Array)
+            new_node = new_child_and_node[1]
+          end
+        end
+        new_node
+      end
+
+      [
+        Language::Nodes::Argument,
+        Language::Nodes::Directive,
+        Language::Nodes::DirectiveDefinition,
+        Language::Nodes::DirectiveLocation,
+        Language::Nodes::Document,
+        Language::Nodes::Enum,
+        Language::Nodes::EnumTypeDefinition,
+        Language::Nodes::EnumTypeExtension,
+        Language::Nodes::EnumValueDefinition,
+        Language::Nodes::Field,
+        Language::Nodes::FieldDefinition,
+        Language::Nodes::FragmentDefinition,
+        Language::Nodes::FragmentSpread,
+        Language::Nodes::InlineFragment,
+        Language::Nodes::InputObject,
+        Language::Nodes::InputObjectTypeDefinition,
+        Language::Nodes::InputObjectTypeExtension,
+        Language::Nodes::InputValueDefinition,
+        Language::Nodes::InterfaceTypeDefinition,
+        Language::Nodes::InterfaceTypeExtension,
+        Language::Nodes::ListType,
+        Language::Nodes::NonNullType,
+        Language::Nodes::NullValue,
+        Language::Nodes::ObjectTypeDefinition,
+        Language::Nodes::ObjectTypeExtension,
+        Language::Nodes::OperationDefinition,
+        Language::Nodes::ScalarTypeDefinition,
+        Language::Nodes::ScalarTypeExtension,
+        Language::Nodes::SchemaDefinition,
+        Language::Nodes::SchemaExtension,
+        Language::Nodes::TypeName,
+        Language::Nodes::UnionTypeDefinition,
+        Language::Nodes::UnionTypeExtension,
+        Language::Nodes::VariableDefinition,
+        Language::Nodes::VariableIdentifier,
+      ].each do |ast_node_class|
+        make_visit_methods(ast_node_class)
+      end
 
       private
 
-      # Run the hooks for `node`, and if the hooks return a copy of `node`,
-      # copy `parent` so that it contains the copy of that node as a child,
-      # then return the copies
-      def on_node_with_modifications(node, parent)
-        new_node_and_new_parent = visit_node(node, parent)
+      def apply_modifications(node, parent, new_node_and_new_parent)
         if new_node_and_new_parent.is_a?(Array)
           new_node = new_node_and_new_parent[0]
           new_parent = new_node_and_new_parent[1]
@@ -177,10 +266,14 @@ module GraphQL
             # The user-provided hook returned a new node.
             new_parent = new_parent && new_parent.replace_child(node, new_node)
             return new_node, new_parent
-          elsif new_node == DELETE_NODE
+          elsif new_node.equal?(DELETE_NODE)
             # The user-provided hook requested to remove this node
             new_parent = new_parent && new_parent.delete_child(node)
             return nil, new_parent
+          elsif new_node_and_new_parent.none? { |n| n == nil || n.class < Nodes::AbstractNode }
+            # The user-provided hook returned an array of who-knows-what
+            # return nil here to signify that no changes should be made
+            nil
           else
             new_node_and_new_parent
           end
@@ -191,43 +284,6 @@ module GraphQL
           new_node_and_new_parent
         end
       end
-
-      def begin_visit(node, parent)
-        node_visitor = self[node.class]
-        self.class.apply_hooks(node_visitor.enter, node, parent)
-      end
-
-      # Should global `leave` visitors come first or last?
-      def end_visit(node, parent)
-        node_visitor = self[node.class]
-        self.class.apply_hooks(node_visitor.leave, node, parent)
-      end
-
-      # If one of the visitors returns SKIP, stop visiting this node
-      def self.apply_hooks(hooks, node, parent)
-        hooks.reduce(true) { |memo, proc| memo && (proc.call(node, parent) != SKIP) }
-      end
-
-      # Collect `enter` and `leave` hooks for classes in {GraphQL::Language::Nodes}
-      #
-      # Access {NodeVisitor}s via {GraphQL::Language::Visitor#[]}
-      class NodeVisitor
-        # @return [Array<Proc>] Hooks to call when entering a node of this type
-        attr_reader :enter
-        # @return [Array<Proc>] Hooks to call when leaving a node of this type
-        attr_reader :leave
-
-        def initialize
-          @enter = []
-          @leave = []
-        end
-
-        # Shorthand to add a hook to the {#enter} array
-        # @param hook [Proc] A hook to add
-        def <<(hook)
-          enter << hook
-        end
-      end
     end
   end
 end

data/lib/graphql/language.rb

@@ -1,14 +1,17 @@
 # frozen_string_literal: true
 require "graphql/language/block_string"
 require "graphql/language/printer"
-require "graphql/language/definition_slice"
+require "graphql/language/sanitized_printer"
 require "graphql/language/document_from_schema_definition"
 require "graphql/language/generation"
 require "graphql/language/lexer"
 require "graphql/language/nodes"
+require "graphql/language/cache"
 require "graphql/language/parser"
+require "graphql/language/static_visitor"
 require "graphql/language/token"
 require "graphql/language/visitor"
+require "graphql/language/definition_slice"
 
 module GraphQL
   module Language

data/lib/graphql/load_application_object_failed_error.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module GraphQL
+  # Raised when a argument is configured with `loads:` and the client provides an `ID`,
+  # but no object is loaded for that ID.
+  #
+  # @see GraphQL::Schema::Member::HasArguments::ArgumentObjectLoader#load_application_object_failed, A hook which you can override in resolvers, mutations and input objects.
+  class LoadApplicationObjectFailedError < GraphQL::ExecutionError
+    # @return [GraphQL::Schema::Argument] the argument definition for the argument that was looked up
+    attr_reader :argument
+    # @return [String] The ID provided by the client
+    attr_reader :id
+    # @return [Object] The value found with this ID
+    attr_reader :object
+    def initialize(argument:, id:, object:)
+      @id = id
+      @argument = argument
+      @object = object
+      super("No object found for `#{argument.graphql_name}: #{id.inspect}`")
+    end
+  end
+end

data/lib/graphql/name_validator.rb

@@ -4,13 +4,8 @@ module GraphQL
     VALID_NAME_REGEX = /^[_a-zA-Z][_a-zA-Z0-9]*$/
 
     def self.validate!(name)
-      raise GraphQL::InvalidNameError.new(name, VALID_NAME_REGEX) unless valid?(name)
-    end
-
-    private
-
-    def self.valid?(name)
-      name =~ VALID_NAME_REGEX
+      name = name.is_a?(String) ? name : name.to_s
+      raise GraphQL::InvalidNameError.new(name, VALID_NAME_REGEX) unless name.match?(VALID_NAME_REGEX)
     end
   end
 end

data/lib/graphql/pagination/active_record_relation_connection.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+require "graphql/pagination/relation_connection"
+
+module GraphQL
+  module Pagination
+    # Customizes `RelationConnection` to work with `ActiveRecord::Relation`s.
+    class ActiveRecordRelationConnection < Pagination::RelationConnection
+      private
+
+      def relation_count(relation)
+        int_or_hash = if already_loaded?(relation)
+          relation.size
+        elsif relation.respond_to?(:unscope)
+          relation.unscope(:order).count(:all)
+        else
+          # Rails 3
+          relation.count
+        end
+        if int_or_hash.is_a?(Integer)
+          int_or_hash
+        else
+          # Grouped relations return count-by-group hashes
+          int_or_hash.length
+        end
+      end
+
+      def relation_limit(relation)
+        if relation.is_a?(Array)
+          nil
+        else
+          relation.limit_value
+        end
+      end
+
+      def relation_offset(relation)
+        if relation.is_a?(Array)
+          nil
+        else
+          relation.offset_value
+        end
+      end
+
+      def null_relation(relation)
+        if relation.respond_to?(:none)
+          relation.none
+        else
+          # Rails 3
+          relation.where("1=2")
+        end
+      end
+
+      def set_limit(nodes, limit)
+        if already_loaded?(nodes)
+          nodes.take(limit)
+        else
+          super
+        end
+      end
+
+      def set_offset(nodes, offset)
+        if already_loaded?(nodes)
+          # If the client sent a bogus cursor beyond the size of the relation,
+          # it might get `nil` from `#[...]`, so return an empty array in that case
+          nodes[offset..-1] || []
+        else
+          super
+        end
+      end
+
+      private
+
+      def already_loaded?(relation)
+        relation.is_a?(Array) || relation.loaded?
+      end
+    end
+  end
+end

data/lib/graphql/pagination/array_connection.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+require "graphql/pagination/connection"
+
+module GraphQL
+  module Pagination
+    class ArrayConnection < Pagination::Connection
+      def nodes
+        load_nodes
+        @nodes
+      end
+
+      def has_previous_page
+        load_nodes
+        @has_previous_page
+      end
+
+      def has_next_page
+        load_nodes
+        @has_next_page
+      end
+
+      def cursor_for(item)
+        idx = items.find_index(item) + 1
+        encode(idx.to_s)
+      end
+
+      private
+
+      def index_from_cursor(cursor)
+        decode(cursor).to_i
+      end
+
+      # Populate all the pagination info _once_,
+      # It doesn't do anything on subsequent calls.
+      def load_nodes
+        @nodes ||= begin
+          sliced_nodes = if before && after
+            end_idx = index_from_cursor(before)-1
+            end_idx < 0 ? [] : items[index_from_cursor(after)..end_idx] || []
+          elsif before
+            end_idx = index_from_cursor(before)-2
+            end_idx < 0 ? [] : items[0..end_idx] || []
+          elsif after
+            items[index_from_cursor(after)..-1] || []
+          else
+            items
+          end
+
+          @has_previous_page = if last
+            # There are items preceding the ones in this result
+            sliced_nodes.count > last
+          elsif after
+            # We've paginated into the Array a bit, there are some behind us
+            index_from_cursor(after) > 0
+          else
+            false
+          end
+
+          @has_next_page = if first
+            # There are more items after these items
+            sliced_nodes.count > first
+          elsif before
+            # The original array is longer than the `before` index
+            index_from_cursor(before) < items.length + 1
+          else
+            false
+          end
+
+          limited_nodes = sliced_nodes
+
+          limited_nodes = limited_nodes.first(first) if first
+          limited_nodes = limited_nodes.last(last) if last
+
+          limited_nodes
+        end
+      end
+    end
+  end
+end