graphql 1.5.3 → 1.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f8a07faba9f807e0d1a1cb2d658dbb03aebd5aff
-  data.tar.gz: 7cc789d4ff25519e433770bab5fbdff0421338c4
+  metadata.gz: eacb69bcf39a028dc32debd2a0f266a6f920fd3d
+  data.tar.gz: 921436c519b6b6b8aff3e4dc03845f8d6108a275
 SHA512:
-  metadata.gz: c4699ee8d911f2a26824b08f938bec2d3b564f28864491d355d242e91dd79b17de8b301d91f8016409cf76da93e811364620bb24637a81a616093df5a16a2035
-  data.tar.gz: f805fd9332370ceb6876dc9e68178a5f1753edb6993e14881eba5b36bb7935502a7419c7a0d03fd0b405533be943f4cc4db50f430b7f61cafd331a3ab97a7858
+  metadata.gz: b8e1d965b82383e8cee0423fa06b7f20ea5fde13bedb8e9cd2316686c7f7e72dd409a55667b81ea9f0e502906bee45e7957cbdd79c44e96618a405bebf81fc98
+  data.tar.gz: 56c92576bee82ce626d332df1070079579c02007ad78718831301de4c815a6d61c57a17464e71498d9e6a4c51412e80de50e2090aca40fed8266b282b6c12a58

data/lib/graphql/define/assign_enum_value.rb

@@ -5,7 +5,7 @@ module GraphQL
     module AssignEnumValue
       def self.call(enum_type, name, desc = nil, deprecation_reason: nil, value: name, &block)
         enum_value = GraphQL::EnumType::EnumValue.define(
-          name: name,
+          name: name.to_s,
           description: desc,
           deprecation_reason: deprecation_reason,
           value: value,

data/lib/graphql/execution/directive_checks.rb

@@ -11,18 +11,18 @@ module GraphQL
       module_function
 
       # @return [Boolean] Should this node be included in the query?
-      def include?(directive_irep_nodes, query)
-        directive_irep_nodes.each do |directive_irep_node|
-          name = directive_irep_node.name
+      def include?(directive_ast_nodes, query)
+        directive_ast_nodes.each do |directive_ast_node|
+          name = directive_ast_node.name
           directive_defn = query.schema.directives[name]
           case name
           when SKIP
-            args = query.arguments_for(directive_irep_node, directive_defn)
+            args = query.arguments_for(directive_ast_node, directive_defn)
             if args['if'] == true
               return false
             end
           when INCLUDE
-            args = query.arguments_for(directive_irep_node, directive_defn)
+            args = query.arguments_for(directive_ast_node, directive_defn)
             if args['if'] == false
               return false
             end

data/lib/graphql/internal_representation.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
 require "graphql/internal_representation/node"
 require "graphql/internal_representation/rewrite"
+require "graphql/internal_representation/scope"
 require "graphql/internal_representation/visit"

data/lib/graphql/internal_representation/node.rb

@@ -8,42 +8,92 @@ module GraphQL
       # @return [GraphQL::ObjectType]
       attr_reader :owner_type
 
-      # @return [Hash<GraphQL::ObjectType, Hash<String => Node>>] selections on this node for each type
-      attr_reader :typed_children
-
-      # @return [Set<Language::Nodes::AbstractNode>] AST nodes which are represented by this node
-      def ast_nodes
-        @ast_nodes ||= Set.new
+      # Each key is a {GraphQL::ObjectType} which this selection _may_ be made on.
+      # The values for that key are selections which apply to that type.
+      #
+      # This value is derived from {#scoped_children} after the rewrite is finished.
+      # @return [Hash<GraphQL::ObjectType, Hash<String => Node>>]
+      def typed_children
+        @typed_childen ||= begin
+          new_tc = Hash.new { |h, k| h[k] = {} }
+          if @scoped_children.any?
+            all_object_types = Set.new
+            scoped_children.each_key { |t| all_object_types.merge(@query.possible_types(t)) }
+            all_object_types.each do |t|
+              new_tc[t] = get_typed_children(t)
+            end
+          end
+          new_tc
+        end
       end
 
-      # @return [Set<GraphQL::Field>] Field definitions for this node (there should only be one!)
-      def definitions
-        @definitions ||= Set.new
-      end
+      # These children correspond closely to scopes in the AST.
+      # Keys _may_ be abstract types. They're assumed to be read-only after rewrite is finished
+      # because {#typed_children} is derived from them.
+      #
+      # Using {#scoped_children} during the rewrite step reduces the overhead of reifying
+      # abstract types because they're only reified _after_ the rewrite.
+      # @return [Hash<GraphQL::BaseType, Hash<String => Node>>]
+      attr_reader :scoped_children
+
+      # @return [Array<Language::Nodes::AbstractNode>] AST nodes which are represented by this node
+      attr_reader :ast_nodes
+
+      # @return [Array<GraphQL::Field>] Field definitions for this node (there should only be one!)
+      attr_reader :definitions
 
       # @return [GraphQL::BaseType]
       attr_reader :return_type
 
+      # @return [InternalRepresentation::Node, nil]
+      attr_reader :parent
+
       def initialize(
-          name:, owner_type:, query:, return_type:,
-          ast_nodes: nil,
-          definitions: nil, typed_children: nil
+          name:, owner_type:, query:, return_type:, parent:,
+          ast_nodes: [],
+          definitions: []
         )
         @name = name
         @query = query
         @owner_type = owner_type
-        @typed_children = typed_children || Hash.new { |h1, k1| h1[k1] = {} }
+        @parent = parent
+        @typed_children = nil
+        @scoped_children = Hash.new { |h1, k1| h1[k1] = {} }
         @ast_nodes = ast_nodes
         @definitions = definitions
         @return_type = return_type
       end
 
+      def initialize_copy(other_node)
+        super
+        # Bust some caches:
+        @typed_children = nil
+        @definition = nil
+        @definition_name = nil
+        @ast_node = nil
+        # Shallow-copy some state:
+        @scoped_children = other_node.scoped_children.dup
+        @ast_nodes = other_node.ast_nodes.dup
+        @definitions = other_node.definitions.dup
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          other.name == name &&
+          other.parent == parent &&
+          other.return_type == return_type &&
+          other.owner_type == owner_type &&
+          other.scoped_children == scoped_children &&
+          other.definitions == definitions &&
+          other.ast_nodes == ast_nodes
+      end
+
       def definition_name
         @definition_name ||= definition.name
       end
 
       def definition
-        @definition ||= definitions.first
+        @definition ||= @query.get_field(@owner_type, @definitions.first.name)
       end
 
       def ast_node
@@ -51,7 +101,58 @@ module GraphQL
       end
 
       def inspect
-        "#<Node #{@owner_type}.#{@name} -> #{@return_type}>"
+        all_children_names = scoped_children.values.map(&:keys).flatten.uniq.join(", ")
+        all_locations = ast_nodes.map {|n| "#{n.line}:#{n.col}" }.join(", ")
+        "#<Node #{@owner_type}.#{@name} -> #{@return_type} {#{all_children_names}} @ [#{all_locations}] #{object_id}>"
+      end
+
+      # Merge selections from `new_parent` into `self`.
+      # Selections are merged in place, not copied.
+      def deep_merge_node(new_parent, merge_self: true)
+        if merge_self
+          @ast_nodes.concat(new_parent.ast_nodes)
+          @definitions.concat(new_parent.definitions)
+        end
+        new_parent.scoped_children.each do |obj_type, new_fields|
+          prev_fields = @scoped_children[obj_type]
+          new_fields.each do |name, new_node|
+            prev_node = prev_fields[name]
+            if prev_node
+              prev_node.deep_merge_node(new_node)
+            else
+              prev_fields[name] = new_node
+            end
+          end
+        end
+      end
+
+      protected
+
+      attr_writer :owner_type, :parent
+
+      private
+
+      # Get applicable children from {#scoped_children}
+      # @param obj_type [GraphQL::ObjectType]
+      # @return [Hash<String => Node>]
+      def get_typed_children(obj_type)
+        new_tc = {}
+        @scoped_children.each do |scope_type, scope_nodes|
+          if GraphQL::Execution::Typecast.subtype?(scope_type, obj_type)
+            scope_nodes.each do |name, new_node|
+              prev_node = new_tc[name]
+              if prev_node
+                prev_node.deep_merge_node(new_node)
+              else
+                copied_node = new_node.dup
+                copied_node.owner_type = obj_type
+                copied_node.parent = self
+                new_tc[name] = copied_node
+              end
+            end
+          end
+        end
+        new_tc
       end
     end
   end

data/lib/graphql/internal_representation/rewrite.rb

@@ -34,17 +34,17 @@ module GraphQL
         # Array<Set<InternalRepresentation::Node>>
         # The current point of the irep_tree during visitation
         nodes_stack = []
-        # Array<Set<GraphQL::ObjectType>>
-        # Object types that the current point of the irep_tree applies to
-        scope_stack = []
+        # Array<Scope>
+        scopes_stack = []
+
         fragment_definitions = {}
         skip_nodes = Set.new
 
-        visit_op = VisitDefinition.new(context, @operations, nodes_stack, scope_stack)
+        visit_op = VisitDefinition.new(context, @operations, nodes_stack, scopes_stack)
         visitor[Nodes::OperationDefinition].enter << visit_op.method(:enter)
         visitor[Nodes::OperationDefinition].leave << visit_op.method(:leave)
 
-        visit_frag = VisitDefinition.new(context, fragment_definitions, nodes_stack, scope_stack)
+        visit_frag = VisitDefinition.new(context, fragment_definitions, nodes_stack, scopes_stack)
         visitor[Nodes::FragmentDefinition].enter << visit_frag.method(:enter)
         visitor[Nodes::FragmentDefinition].leave << visit_frag.method(:leave)
 
@@ -52,28 +52,18 @@ module GraphQL
           # Inline fragments provide two things to the rewritten tree:
           # - They _may_ narrow the scope by their type condition
           # - They _may_ apply their directives to their children
-
           if skip?(ast_node, query)
             skip_nodes.add(ast_node)
           end
 
           if skip_nodes.none?
-            next_scope = Set.new
-            prev_scope = scope_stack.last
-            each_type(query, context.type_definition) do |obj_type|
-              # What this fragment can apply to is also determined by
-              # the scope around it (it can't widen the scope)
-              if prev_scope.include?(obj_type)
-                next_scope.add(obj_type)
-              end
-            end
-            scope_stack.push(next_scope)
+            scopes_stack.push(scopes_stack.last.enter(context.type_definition))
           end
         }
 
         visitor[Nodes::InlineFragment].leave << ->(ast_node, ast_parent) {
           if skip_nodes.none?
-            scope_stack.pop
+            scopes_stack.pop
           end
 
           if skip_nodes.include?(ast_node)
@@ -90,42 +80,39 @@ module GraphQL
             node_name = ast_node.alias || ast_node.name
             parent_nodes = nodes_stack.last
             next_nodes = []
-            next_scope = Set.new
-            applicable_scope = scope_stack.last
-
-            applicable_scope.each do |obj_type|
-              # Can't use context.field_definition because that might be
-              # a definition on an interface type
-              field_defn = query.get_field(obj_type, ast_node.name)
-              if field_defn.nil?
-                # It's a non-existent field
-              else
-                field_return_type = field_defn.type.unwrap
-                each_type(query, field_return_type) do |obj_type|
-                  next_scope.add(obj_type)
-                end
+
+            field_defn = context.field_definition
+            if field_defn.nil?
+              # It's a non-existent field
+              new_scope = nil
+            else
+              field_return_type = field_defn.type.unwrap
+              scopes_stack.last.each do |scope_type|
                 parent_nodes.each do |parent_node|
-                  node = parent_node.typed_children[obj_type][node_name] ||= Node.new(
+                  node = parent_node.scoped_children[scope_type][node_name] ||= Node.new(
+                    parent: parent_node,
                     name: node_name,
-                    owner_type: obj_type,
+                    owner_type: scope_type,
                     query: query,
                     return_type: field_return_type,
                   )
-                  node.ast_nodes.add(ast_node)
-                  node.definitions.add(field_defn)
+                  node.ast_nodes << ast_node
+                  node.definitions << field_defn
                   next_nodes << node
                 end
               end
+              new_scope = Scope.new(query, field_return_type)
             end
+
             nodes_stack.push(next_nodes)
-            scope_stack.push(next_scope)
+            scopes_stack.push(new_scope)
           end
         }
 
         visitor[Nodes::Field].leave << ->(ast_node, ast_parent) {
           if skip_nodes.none?
             nodes_stack.pop
-            scope_stack.pop
+            scopes_stack.pop
           end
 
           if skip_nodes.include?(ast_node)
@@ -147,97 +134,55 @@ module GraphQL
         # can be shared between its usages.
         context.on_dependency_resolve do |defn_ast_node, spread_ast_nodes, frag_ast_node|
           frag_name = frag_ast_node.name
-          spread_ast_nodes.each do |spread_ast_node|
-            parent_nodes = spread_parents[spread_ast_node]
-            parent_nodes.each do |parent_node|
-              fragment_node = fragment_definitions[frag_name]
-              if fragment_node
-                deep_merge_selections(query, parent_node, fragment_node)
-              end
-            end
-          end
-        end
-      end
+          fragment_node = fragment_definitions[frag_name]
 
-      # Merge selections from `new_parent` into `prev_parent`.
-      # If `new_parent` came from a spread in the AST, it's present as `spread`.
-      # Selections are merged in place, not copied.
-      def deep_merge_selections(query, prev_parent, new_parent)
-        new_parent.typed_children.each do |obj_type, new_fields|
-          prev_fields = prev_parent.typed_children[obj_type]
-          new_fields.each do |name, new_node|
-            prev_node = prev_fields[name]
-            if prev_node
-              prev_node.ast_nodes.merge(new_node.ast_nodes)
-              prev_node.definitions.merge(new_node.definitions)
-              deep_merge_selections(query, prev_node, new_node)
-            else
-              prev_fields[name] = new_node
+          if fragment_node
+            spread_ast_nodes.each do |spread_ast_node|
+              parent_nodes = spread_parents[spread_ast_node]
+              parent_nodes.each do |parent_node|
+                parent_node.deep_merge_node(fragment_node, merge_self: false)
+              end
             end
           end
         end
       end
 
-      # @see {.each_type}
-      def each_type(query, owner_type, &block)
-        self.class.each_type(query, owner_type, &block)
-      end
-
-      # Call the block for each of `owner_type`'s possible types
-      def self.each_type(query, owner_type)
-        case owner_type
-        when GraphQL::ObjectType, GraphQL::ScalarType, GraphQL::EnumType
-          yield(owner_type)
-        when GraphQL::UnionType, GraphQL::InterfaceType
-          query.possible_types(owner_type).each(&Proc.new)
-        when GraphQL::InputObjectType, nil
-          # this is an error, don't give 'em nothin
-        else
-          raise "Unexpected owner type: #{owner_type.inspect}"
-        end
-      end
-
       def skip?(ast_node, query)
         dir = ast_node.directives
         dir.any? && !GraphQL::Execution::DirectiveChecks.include?(dir, query)
       end
 
       class VisitDefinition
-        def initialize(context, definitions, nodes_stack, scope_stack)
+        def initialize(context, definitions, nodes_stack, scopes_stack)
           @context = context
           @query = context.query
           @definitions = definitions
           @nodes_stack = nodes_stack
-          @scope_stack = scope_stack
+          @scopes_stack = scopes_stack
         end
 
         def enter(ast_node, ast_parent)
           # Either QueryType or the fragment type condition
           owner_type = @context.type_definition && @context.type_definition.unwrap
-          next_nodes = []
-          next_scope = Set.new
           defn_name = ast_node.name
-          Rewrite.each_type(@query, owner_type) do |obj_type|
-            next_scope.add(obj_type)
-          end
 
           node = Node.new(
+            parent: nil,
             name: defn_name,
             owner_type: owner_type,
             query: @query,
-            ast_nodes: Set.new([ast_node]),
+            ast_nodes: [ast_node],
             return_type: owner_type,
           )
-          @definitions[defn_name] = node
-          next_nodes << node
 
-          @nodes_stack.push(next_nodes)
-          @scope_stack.push(next_scope)
+          @definitions[defn_name] = node
+          @scopes_stack.push(Scope.new(@query, owner_type))
+          @nodes_stack.push([node])
         end
 
         def leave(ast_node, ast_parent)
           @nodes_stack.pop
-          @scope_stack.pop
+          @scopes_stack.pop
         end
       end
     end

data/lib/graphql/internal_representation/scope.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+module GraphQL
+  module InternalRepresentation
+    # At a point in the AST, selections may apply to one or more types.
+    # {Scope} represents those types which selections may apply to.
+    #
+    # Scopes can be defined by:
+    #
+    # - A single concrete or abstract type
+    # - An array of types
+    # - `nil`
+    #
+    # The AST may be scoped to an array of types when two abstractly-typed
+    # fragments occur in inside one another.
+    class Scope
+      NO_TYPES = [].freeze
+
+      # @param query [GraphQL::Query]
+      # @param type_defn [GraphQL::BaseType, Array<GraphQL::BaseType>, nil]
+      def initialize(query, type_defn)
+        @query = query
+        @type = type_defn
+        @abstract_type = false
+        @types = case type_defn
+        when Array
+          type_defn
+        when GraphQL::BaseType
+          @abstract_type = true
+          nil
+        when nil
+          NO_TYPES
+        else
+          raise "Unexpected scope type: #{type_defn}"
+        end
+      end
+
+      # From a starting point of `self`, create a new scope by condition `other_type_defn`.
+      # @param other_type_defn [GraphQL::BaseType, nil]
+      # @return [Scope]
+      def enter(other_type_defn)
+        case other_type_defn
+        when nil
+          # The type wasn't found, who cares
+          Scope.new(@query, nil)
+        when @type
+          # The condition is the same as current, so reuse self
+          self
+        when GraphQL::UnionType, GraphQL::InterfaceType
+          # Make a new scope of the intersection between the previous & next conditions
+          new_types = @query.possible_types(other_type_defn) & concrete_types
+          Scope.new(@query, new_types)
+        when GraphQL::BaseType
+          # If this type is valid within the current scope,
+          # return a new scope of _exactly_ this type.
+          # Otherwise, this type is out-of-scope so the scope is null.
+          if concrete_types.include?(other_type_defn)
+            Scope.new(@query, other_type_defn)
+          else
+            Scope.new(@query, nil)
+          end
+        else
+          raise "Unexpected scope: #{other_type_defn.inspect}"
+        end
+      end
+
+      # Call the block for each type in `self`.
+      # This uses the simplest possible expression of `self`,
+      # so if this scope is defined by an abstract type, it gets yielded.
+      def each
+        if @abstract_type
+          yield(@type)
+        else
+          @types.each { |t| yield(t) }
+        end
+      end
+
+      private
+
+      def concrete_types
+        @concrete_types ||= if @abstract_type
+          @query.possible_types(@type)
+        else
+          @types
+        end
+      end
+    end
+  end
+end