graphql 0.16.0 → 2.0.15

data/lib/graphql/language/visitor.rb

@@ -1,40 +1,63 @@
+# frozen_string_literal: true
 module GraphQL
   module Language
     # Depth-first traversal through the tree, calling hooks at each stop.
     #
-    # @example Create a visitor, add hooks, then search a document
-    #   total_field_count = 0
-    #   visitor = GraphQL::Language::Visitor.new(document)
-    #   # Whenever you find a field, increment the field count:
-    #   visitor[GraphQL::Language::Nodes::Field] << -> (node) { total_field_count += 1 }
-    #   # When we finish, print the field count:
-    #   visitor[GraphQL::Language::Nodes::Document].leave << -> (node) { p total_field_count }
-    #   visitor.visit
-    #   # => 6
+    # @example Create a visitor counting certain field names
+    #   class NameCounter < GraphQL::Language::Visitor
+    #     def initialize(document, field_name)
+    #       super(document)
+    #       @field_name = field_name
+    #       @count = 0
+    #     end
+    #
+    #     attr_reader :count
+    #
+    #     def on_field(node, parent)
+    #       # if this field matches our search, increment the counter
+    #       if node.name == @field_name
+    #         @count += 1
+    #       end
+    #       # Continue visiting subfields:
+    #       super
+    #     end
+    #   end
     #
+    #   # Initialize a visitor
+    #   visitor = NameCounter.new(document, "name")
+    #   # Run it
+    #   visitor.visit
+    #   # Check the result
+    #   visitor.count
+    #   # => 3
     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
 
-      # @return [Array<Proc>] Hooks to call when entering _any_ node
-      attr_reader :enter
-      # @return [Array<Proc>] Hooks to call when leaving _any_ node
-      attr_reader :leave
+      class DeleteNode; end
+
+      # When this is returned from a visitor method,
+      # Then the `node` passed into the method is removed from `parent`'s children.
+      DELETE_NODE = DeleteNode.new
 
       def initialize(document)
         @document = document
         @visitors = {}
-        @enter = []
-        @leave = []
+        @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" }
+      #   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
@@ -42,35 +65,156 @@ module GraphQL
       # Visit `document` and all children, applying hooks as you go
       # @return [void]
       def visit
-        visit_node(@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
 
+      # 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.equal?(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
+          no_hooks = !@visitors.key?(node.class)
+          if no_hooks || begin_visit(new_node, parent)
+            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]
+              end
+            end
+          end
+          end_visit(new_node, parent) unless no_hooks
+
+          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)
+        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]
+          end
+        RUBY
+      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
 
-      def visit_node(node, parent)
-        begin_hooks_ok = begin_visit(node, parent)
-        if begin_hooks_ok
-          node.children.reduce(true) { |memo, child| memo && visit_node(child, node) }
+      # 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
+      # If a non-array value is returned, consuming functions should ignore
+      # said value
+      def on_node_with_modifications(node, parent)
+        new_node_and_new_parent = visit_node(node, 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]
+          if new_node.is_a?(Nodes::AbstractNode) && !node.equal?(new_node)
+            # 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.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
+        else
+          # 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.
+          new_node_and_new_parent
         end
-        end_visit(node, parent)
       end
 
       def begin_visit(node, parent)
-        self.class.apply_hooks(enter, 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)
-        self.class.apply_hooks(leave, 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) }
+        hooks.each do |proc|
+          return false if proc.call(node, parent) == SKIP
+        end
+        true
       end
 
       # Collect `enter` and `leave` hooks for classes in {GraphQL::Language::Nodes}

data/lib/graphql/language.rb

@@ -1,6 +1,36 @@
+# frozen_string_literal: true
+require "graphql/language/block_string"
+require "graphql/language/printer"
+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/token"
 require "graphql/language/visitor"
+require "graphql/language/definition_slice"
+
+module GraphQL
+  module Language
+    # @api private
+    def self.serialize(value)
+      if value.is_a?(Hash)
+        serialized_hash = value.map do |k, v|
+          "#{k}:#{serialize v}"
+        end.join(",")
+
+        "{#{serialized_hash}}"
+      elsif value.is_a?(Array)
+        serialized_array = value.map do |v|
+          serialize v
+        end.join(",")
+
+        "[#{serialized_array}]"
+      else
+        JSON.generate(value, quirks_mode: true)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+module GraphQL
+  class NameValidator
+    VALID_NAME_REGEX = /^[_a-zA-Z][_a-zA-Z0-9]*$/
+
+    def self.validate!(name)
+      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,85 @@
+# 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_larger_than(relation, initial_offset, size)
+        if already_loaded?(relation)
+          (relation.size + initial_offset) > size
+        else
+          set_offset(sliced_nodes, initial_offset + size).exists?
+        end
+      end
+
+      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