graphql 2.0.27 → 2.1.3

data/lib/graphql/language/sanitized_printer.rb

@@ -40,7 +40,7 @@ module GraphQL
         case node
         when FalseClass, Float, Integer, String, TrueClass
           if @current_argument && redact_argument_value?(@current_argument, node)
-            redacted_argument_value(@current_argument)
+            print_string(redacted_argument_value(@current_argument))
           else
             super
           end
@@ -51,9 +51,8 @@ module GraphQL
             @current_input_type = @current_input_type.of_type if @current_input_type.non_null?
           end
 
-          res = super
+          super
           @current_input_type = old_input_type
-          res
         else
           super
         end
@@ -89,11 +88,12 @@ module GraphQL
         else
           argument.value
         end
-        res = "#{argument.name}: #{print_node(argument_value)}".dup
+
+        print_string("#{argument.name}: ")
+        print_node(argument_value)
 
         @current_input_type = old_input_type
         @current_argument = old_current_argument
-        res
       end
 
       def coerce_argument_value_to_list?(type, value)
@@ -116,9 +116,8 @@ module GraphQL
         @current_field = query.get_field(@current_type, field.name)
         old_type = @current_type
         @current_type = @current_field.type.unwrap
-        res = super
+        super
         @current_type = old_type
-        res
       end
 
       def print_inline_fragment(inline_fragment, indent: "")
@@ -128,31 +127,26 @@ module GraphQL
           @current_type = query.get_type(inline_fragment.type.name)
         end
 
-        res = super
+        super
 
         @current_type = old_type
-
-        res
       end
 
       def print_fragment_definition(fragment_def, indent: "")
         old_type = @current_type
         @current_type = query.get_type(fragment_def.type.name)
 
-        res = super
+        super
 
         @current_type = old_type
-
-        res
       end
 
       def print_directive(directive)
         @current_directive = query.schema.directives[directive.name]
 
-        res = super
+        super
 
         @current_directive = nil
-        res
       end
 
       # Print the operation definition but do not include the variable
@@ -162,16 +156,15 @@ module GraphQL
         @current_type = query.schema.public_send(operation_definition.operation_type)
 
         if @inline_variables
-          out = "#{indent}#{operation_definition.operation_type}".dup
-          out << " #{operation_definition.name}" if operation_definition.name
-          out << print_directives(operation_definition.directives)
-          out << print_selections(operation_definition.selections, indent: indent)
+          print_string("#{indent}#{operation_definition.operation_type}")
+          print_string(" #{operation_definition.name}") if operation_definition.name
+          print_directives(operation_definition.directives)
+          print_selections(operation_definition.selections, indent: indent)
         else
-          out = super
+          super
         end
 
         @current_type = old_type
-        out
       end
 
       private
@@ -210,7 +203,12 @@ module GraphQL
             [value].map { |v| value_to_ast(v, type.of_type) }
           end
         when "ENUM"
-          GraphQL::Language::Nodes::Enum.new(name: value)
+          if value.is_a?(GraphQL::Language::Nodes::Enum)
+            # if it was a default value, it's already wrapped
+            value
+          else
+            GraphQL::Language::Nodes::Enum.new(name: value)
+          end
         else
           value
         end

data/lib/graphql/language/static_visitor.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+module GraphQL
+  module Language
+    # Like `GraphQL::Language::Visitor` except it doesn't support
+    # making changes to the document -- only visiting it as-is.
+    class StaticVisitor
+      def initialize(document)
+        @document = document
+      end
+
+      # Visit `document` and all children
+      # @return [void]
+      def visit
+        # `@document` may be any kind of node:
+        visit_method = @document.visit_method
+        result = public_send(visit_method, @document, nil)
+        @result = if result.is_a?(Array)
+          result.first
+        else
+          # The node wasn't modified
+          @document
+        end
+      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"
+
+        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 [void]
+          def #{node_method}(node, parent)
+            #{
+              if method_defined?(child_visit_method)
+                "#{child_visit_method}(node)"
+              elsif children_of_type
+                children_of_type.map do |child_accessor, child_class|
+                  "node.#{child_accessor}.each do |child_node|
+                    #{child_class.visit_method}(child_node, node)
+                  end"
+                end.join("\n")
+              else
+                ""
+              end
+            }
+          end
+        RUBY
+      end
+
+      def on_document_children(document_node)
+        document_node.children.each do |child_node|
+          visit_method = child_node.visit_method
+          public_send(visit_method, child_node, document_node)
+        end
+      end
+
+      def on_field_children(new_node)
+        new_node.arguments.each do |arg_node| # rubocop:disable Development/ContextIsPassedCop
+          on_argument(arg_node, new_node)
+        end
+        visit_directives(new_node)
+        visit_selections(new_node)
+      end
+
+      def visit_directives(new_node)
+        new_node.directives.each do |dir_node|
+          on_directive(dir_node, new_node)
+        end
+      end
+
+      def visit_selections(new_node)
+        new_node.selections.each do |selection|
+          case selection
+          when GraphQL::Language::Nodes::Field
+            on_field(selection, new_node)
+          when GraphQL::Language::Nodes::InlineFragment
+            on_inline_fragment(selection, new_node)
+          when GraphQL::Language::Nodes::FragmentSpread
+            on_fragment_spread(selection, new_node)
+          else
+            raise ArgumentError, "Invariant: unexpected field selection #{selection.class} (#{selection.inspect})"
+          end
+        end
+      end
+
+      def on_fragment_definition_children(new_node)
+        visit_directives(new_node)
+        visit_selections(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|
+          on_variable_definition(arg_node, new_node)
+        end
+        visit_directives(new_node)
+        visit_selections(new_node)
+      end
+
+      def on_argument_children(new_node)
+        new_node.children.each do |value_node|
+          case value_node
+          when Language::Nodes::VariableIdentifier
+            on_variable_identifier(value_node, new_node)
+          when Language::Nodes::InputObject
+            on_input_object(value_node, new_node)
+          when Language::Nodes::Enum
+            on_enum(value_node, new_node)
+          when Language::Nodes::NullValue
+            on_null_value(value_node, new_node)
+          else
+            raise ArgumentError, "Invariant: unexpected argument value node #{value_node.class} (#{value_node.inspect})"
+          end
+        end
+      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
+    end
+  end
+end

data/lib/graphql/language/visitor.rb

@@ -30,12 +30,9 @@ module GraphQL
     #   # 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,25 +41,13 @@ 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
         # `@document` may be any kind of node:
@@ -88,7 +73,6 @@ module GraphQL
           # To customize this hook, override one of its make_visit_methods (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`.
@@ -98,29 +82,24 @@ module GraphQL
               # by a user hook, don't want to keep visiting in that case.
               [node, parent]
             else
-              # Run hooks if there are any
               new_node = node
-              no_hooks = !@visitors.key?(node.class)
-              if no_hooks || begin_visit(new_node, parent)
-                #{
-                  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
-                }
-              end
-              end_visit(new_node, parent) unless no_hooks
+              #{
+                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]
@@ -305,46 +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.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}
-      #
-      # 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

@@ -8,6 +8,7 @@ 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"

data/lib/graphql/pagination/connection.rb

@@ -19,7 +19,14 @@ module GraphQL
       attr_reader :items
 
       # @return [GraphQL::Query::Context]
-      attr_accessor :context
+      attr_reader :context
+
+      def context=(new_ctx)
+        current_runtime_state = Thread.current[:__graphql_runtime_info]
+        query_runtime_state = current_runtime_state[new_ctx.query]
+        @was_authorized_by_scope_items = query_runtime_state.was_authorized_by_scope_items
+        @context = new_ctx
+      end
 
       # @return [Object] the object this collection belongs to
       attr_accessor :parent
@@ -83,6 +90,17 @@ module GraphQL
         else
           default_page_size
         end
+        @was_authorized_by_scope_items = if @context
+          current_runtime_state = Thread.current[:__graphql_runtime_info]
+          query_runtime_state = current_runtime_state[@context.query]
+          query_runtime_state.was_authorized_by_scope_items
+        else
+          nil
+        end
+      end
+
+      def was_authorized_by_scope_items?
+        @was_authorized_by_scope_items
       end
 
       def max_page_size=(new_value)
@@ -247,6 +265,10 @@ module GraphQL
         def cursor
           @cursor ||= @connection.cursor_for(@node)
         end
+
+        def was_authorized_by_scope_items?
+          @connection.was_authorized_by_scope_items?
+        end
       end
     end
   end

data/lib/graphql/query/context/scoped_context.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+module GraphQL
+  class Query
+    class Context
+      class ScopedContext
+        def initialize(query_context)
+          @query_context = query_context
+          @scoped_contexts = nil
+          @all_keys = nil
+        end
+
+        def merged_context
+          if @scoped_contexts.nil?
+            GraphQL::EmptyObjects::EMPTY_HASH
+          else
+            merged_ctx = {}
+            each_present_path_ctx do |path_ctx|
+              merged_ctx = path_ctx.merge(merged_ctx)
+            end
+            merged_ctx
+          end
+        end
+
+        def merge!(hash, at: current_path)
+          @all_keys ||= Set.new
+          @all_keys.merge(hash.keys)
+          ctx = @scoped_contexts ||= {}
+          at.each do |path_part|
+            ctx = ctx[path_part] ||= { parent: ctx }
+          end
+          this_scoped_ctx = ctx[:scoped_context] ||= {}
+          this_scoped_ctx.merge!(hash)
+        end
+
+        def key?(key)
+          if @all_keys && @all_keys.include?(key)
+            each_present_path_ctx do |path_ctx|
+              if path_ctx.key?(key)
+                return true
+              end
+            end
+          end
+          false
+        end
+
+        def [](key)
+          each_present_path_ctx do |path_ctx|
+            if path_ctx.key?(key)
+              return path_ctx[key]
+            end
+          end
+          nil
+        end
+
+        def current_path
+          @query_context.current_path || GraphQL::EmptyObjects::EMPTY_ARRAY
+        end
+
+        def dig(key, *other_keys)
+          each_present_path_ctx do |path_ctx|
+            if path_ctx.key?(key)
+              found_value = path_ctx[key]
+              if other_keys.any?
+                return found_value.dig(*other_keys)
+              else
+                return found_value
+              end
+            end
+          end
+          nil
+        end
+
+        private
+
+        # Start at the current location,
+        # but look up the tree for previously-assigned scoped values
+        def each_present_path_ctx
+          ctx = @scoped_contexts
+          if ctx.nil?
+            # no-op
+          else
+            current_path.each do |path_part|
+              if ctx.key?(path_part)
+                ctx = ctx[path_part]
+              else
+                break
+              end
+            end
+
+            while ctx
+              if (scoped_ctx = ctx[:scoped_context])
+                yield(scoped_ctx)
+              end
+              ctx = ctx[:parent]
+            end
+          end
+        end
+      end
+    end
+  end
+end