graphql 1.13.20 → 2.0.0

data/lib/graphql/internal_representation/node.rb

@@ -1,206 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module InternalRepresentation
-    class Node
-      # @api private
-      DEFAULT_TYPED_CHILDREN = Proc.new { |h, k| h[k] = {} }
-
-      # A specialized, reusable object for leaf nodes.
-      NO_TYPED_CHILDREN = Hash.new({}.freeze)
-      def NO_TYPED_CHILDREN.dup; self; end;
-      NO_TYPED_CHILDREN.freeze
-
-      # @return [String] the name this node has in the response
-      attr_reader :name
-
-      # @return [GraphQL::ObjectType]
-      attr_reader :owner_type
-
-      # 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_children ||= begin
-          if @scoped_children.any?
-            new_tc = Hash.new(&DEFAULT_TYPED_CHILDREN)
-            all_object_types = Set.new
-            scoped_children.each_key { |t| all_object_types.merge(@query.possible_types(t)) }
-            # Remove any scoped children which don't follow this return type
-            # (This can happen with fragment merging where lexical scope is lost)
-            all_object_types &= @query.possible_types(@return_type.unwrap)
-            all_object_types.each do |t|
-              new_tc[t] = get_typed_children(t)
-            end
-            new_tc
-          else
-            NO_TYPED_CHILDREN
-          end
-
-        end
-      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] The expected wrapped type this node must return.
-      attr_reader :return_type
-
-      # @return [InternalRepresentation::Node, nil]
-      attr_reader :parent
-
-      def initialize(
-          name:, owner_type:, query:, return_type:, parent:,
-          ast_nodes: [],
-          definitions: []
-        )
-        @name = name
-        @query = query
-        @owner_type = owner_type
-        @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 && definition.name
-      end
-
-      def arguments
-        @query.arguments_for(self, definition)
-      end
-
-      def definition
-        @definition ||= begin
-          first_def = @definitions.first
-          first_def && @query.get_field(@owner_type, first_def.name)
-        end
-      end
-
-      def ast_node
-        @ast_node ||= ast_nodes.first
-      end
-
-      def inspect
-        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, scope: nil, merge_self: true)
-        if merge_self
-          @ast_nodes |= new_parent.ast_nodes
-          @definitions |= new_parent.definitions
-        end
-        new_sc = new_parent.scoped_children
-        if new_sc.any?
-          scope ||= Scope.new(@query, @return_type.unwrap)
-          new_sc.each do |obj_type, new_fields|
-            inner_scope = scope.enter(obj_type)
-            inner_scope.each do |scoped_type|
-              prev_fields = @scoped_children[scoped_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
-        end
-      end
-
-      # @return [GraphQL::Query]
-      attr_reader :query
-
-      def subscription_topic
-        @subscription_topic ||= begin
-          scope = if definition.subscription_scope
-            @query.context[definition.subscription_scope]
-          else
-            nil
-          end
-          Subscriptions::Event.serialize(
-            definition_name,
-            @query.arguments_for(self, definition),
-            definition,
-            scope: scope
-          )
-        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
-end

data/lib/graphql/internal_representation/print.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module InternalRepresentation
-    module Print
-      module_function
-
-      def print(schema, query_string)
-        query = GraphQL::Query.new(schema, query_string)
-        print_node(query.irep_selection)
-      end
-
-      def print_node(node, indent: 0)
-        padding = " " * indent
-        typed_children_padding = " " * (indent + 2)
-        query_str = "".dup
-
-        if !node.definition
-          op_node = node.ast_node
-          name = op_node.name ? " " + op_node.name : ""
-          op_type = op_node.operation_type
-          query_str << "#{op_type}#{name}"
-        else
-          if node.name == node.definition_name
-            query_str << "#{padding}#{node.name}"
-          else
-            query_str << "#{padding}#{node.name}: #{node.definition_name}"
-          end
-
-          args = node.ast_nodes.map { |n| n.arguments.map(&:to_query_string).join(",") }.uniq
-          query_str << args.map { |a| "(#{a})"}.join("|")
-        end
-
-        if node.typed_children.any?
-          query_str << " {\n"
-          node.typed_children.each do |type, children|
-            query_str << "#{typed_children_padding}... on #{type.name} {\n"
-            children.each do |name, child|
-              query_str << print_node(child, indent: indent + 4)
-            end
-            query_str << "#{typed_children_padding}}\n"
-          end
-          query_str << "#{padding}}\n"
-        else
-          query_str << "\n"
-        end
-
-        query_str
-      end
-    end
-  end
-end

data/lib/graphql/internal_representation/rewrite.rb

@@ -1,184 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module InternalRepresentation
-    # While visiting an AST, build a normalized, flattened tree of {InternalRepresentation::Node}s.
-    #
-    # No unions or interfaces are present in this tree, only object types.
-    #
-    # Selections from the AST are attached to the object types they apply to.
-    #
-    # Inline fragments and fragment spreads are preserved in {InternalRepresentation::Node#ast_spreads},
-    # where they can be used to check for the presence of directives. This might not be sufficient
-    # for future directives, since the selections' grouping is lost.
-    #
-    # The rewritten query tree serves as the basis for the `FieldsWillMerge` validation.
-    #
-    module Rewrite
-      include GraphQL::Language
-
-      NO_DIRECTIVES = [].freeze
-
-      # @return InternalRepresentation::Document
-      attr_reader :rewrite_document
-
-      def initialize(*)
-        super
-        @query = context.query
-        @rewrite_document = InternalRepresentation::Document.new
-        # Hash<Nodes::FragmentSpread => Set<InternalRepresentation::Node>>
-        # A record of fragment spreads and the irep nodes that used them
-        @rewrite_spread_parents = Hash.new { |h, k| h[k] = Set.new }
-        # Hash<Nodes::FragmentSpread => Scope>
-        @rewrite_spread_scopes = {}
-        # Array<Set<InternalRepresentation::Node>>
-        # The current point of the irep_tree during visitation
-        @rewrite_nodes_stack = []
-        # Array<Scope>
-        @rewrite_scopes_stack = []
-        @rewrite_skip_nodes = Set.new
-
-        # Resolve fragment spreads.
-        # Fragment definitions got their own irep trees during visitation.
-        # Those nodes are spliced in verbatim (not copied), but this is OK
-        # because fragments are resolved from the "bottom up", each fragment
-        # 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
-          fragment_node = @rewrite_document.fragment_definitions[frag_name]
-
-          if fragment_node
-            spread_ast_nodes.each do |spread_ast_node|
-              parent_nodes = @rewrite_spread_parents[spread_ast_node]
-              parent_scope = @rewrite_spread_scopes[spread_ast_node]
-              parent_nodes.each do |parent_node|
-                parent_node.deep_merge_node(fragment_node, scope: parent_scope, merge_self: false)
-              end
-            end
-          end
-        end
-      end
-
-      # @return [Hash<String, Node>] Roots of this query
-      def operations
-        GraphQL::Deprecation.warn "#{self.class}#operations is deprecated; use `document.operation_definitions` instead"
-        @document.operation_definitions
-      end
-
-      def on_operation_definition(ast_node, parent)
-        push_root_node(ast_node, @rewrite_document.operation_definitions) { super }
-      end
-
-      def on_fragment_definition(ast_node, parent)
-        push_root_node(ast_node, @rewrite_document.fragment_definitions) { super }
-      end
-
-      def push_root_node(ast_node, definitions)
-        # Either QueryType or the fragment type condition
-        owner_type = context.type_definition
-        defn_name = ast_node.name
-
-        node = Node.new(
-          parent: nil,
-          name: defn_name,
-          owner_type: owner_type,
-          query: @query,
-          ast_nodes: [ast_node],
-          return_type: owner_type,
-        )
-
-        definitions[defn_name] = node
-        @rewrite_scopes_stack.push(Scope.new(@query, owner_type))
-        @rewrite_nodes_stack.push([node])
-        yield
-        @rewrite_nodes_stack.pop
-        @rewrite_scopes_stack.pop
-      end
-
-      def on_inline_fragment(node, parent)
-        # 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?(node)
-          @rewrite_skip_nodes.add(node)
-        end
-
-        if @rewrite_skip_nodes.empty?
-          @rewrite_scopes_stack.push(@rewrite_scopes_stack.last.enter(context.type_definition))
-        end
-
-        super
-
-        if @rewrite_skip_nodes.empty?
-          @rewrite_scopes_stack.pop
-        end
-
-        if @rewrite_skip_nodes.include?(node)
-          @rewrite_skip_nodes.delete(node)
-        end
-      end
-
-      def on_field(ast_node, ast_parent)
-        if skip?(ast_node)
-          @rewrite_skip_nodes.add(ast_node)
-        end
-
-        if @rewrite_skip_nodes.empty?
-          node_name = ast_node.alias || ast_node.name
-          parent_nodes = @rewrite_nodes_stack.last
-          next_nodes = []
-
-          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
-            @rewrite_scopes_stack.last.each do |scope_type|
-              parent_nodes.each do |parent_node|
-                node = parent_node.scoped_children[scope_type][node_name] ||= Node.new(
-                  parent: parent_node,
-                  name: node_name,
-                  owner_type: scope_type,
-                  query: @query,
-                  return_type: field_return_type,
-                )
-                node.ast_nodes << ast_node
-                node.definitions << field_defn
-                next_nodes << node
-              end
-            end
-            new_scope = Scope.new(@query, field_return_type.unwrap)
-          end
-
-          @rewrite_nodes_stack.push(next_nodes)
-          @rewrite_scopes_stack.push(new_scope)
-        end
-
-        super
-
-        if @rewrite_skip_nodes.empty?
-          @rewrite_nodes_stack.pop
-          @rewrite_scopes_stack.pop
-        end
-
-        if @rewrite_skip_nodes.include?(ast_node)
-          @rewrite_skip_nodes.delete(ast_node)
-        end
-      end
-
-      def on_fragment_spread(ast_node, ast_parent)
-        if @rewrite_skip_nodes.empty? && !skip?(ast_node)
-          # Register the irep nodes that depend on this AST node:
-          @rewrite_spread_parents[ast_node].merge(@rewrite_nodes_stack.last)
-          @rewrite_spread_scopes[ast_node] = @rewrite_scopes_stack.last
-        end
-        super
-      end
-
-      def skip?(ast_node)
-        dir = ast_node.directives
-        dir.any? && !GraphQL::Execution::DirectiveChecks.include?(dir, @query)
-      end
-    end
-  end
-end

data/lib/graphql/internal_representation/scope.rb

@@ -1,88 +0,0 @@
-# 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(&block)
-        if @abstract_type
-          yield(@type)
-        else
-          @types.each(&block)
-        end
-      end
-
-      private
-
-      def concrete_types
-        @concrete_types ||= if @abstract_type
-          @query.possible_types(@type)
-        else
-          @types
-        end
-      end
-    end
-  end
-end

data/lib/graphql/internal_representation/visit.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module InternalRepresentation
-    # Traverse a re-written query tree, calling handlers for each node
-    module Visit
-      module_function
-      def visit_each_node(operations, handlers)
-        return if handlers.empty?
-        # Post-validation: make some assertions about the rewritten query tree
-        operations.each do |op_name, op_node|
-          # Yield each node to listeners which were attached by validators
-          op_node.typed_children.each do |obj_type, children|
-            children.each do |name, op_child_node|
-              each_node(op_child_node) do |node|
-                for h in handlers
-                  h.call(node)
-                end
-              end
-            end
-          end
-        end
-      end
-
-      # Traverse a node in a rewritten query tree,
-      # visiting the node itself and each of its typed children.
-      def each_node(node, &block)
-        yield(node)
-        node.typed_children.each do |obj_type, children|
-          children.each do |name, node|
-            each_node(node, &block)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/graphql/internal_representation.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-require "graphql/internal_representation/document"
-require "graphql/internal_representation/node"
-require "graphql/internal_representation/print"
-require "graphql/internal_representation/rewrite"
-require "graphql/internal_representation/scope"
-require "graphql/internal_representation/visit"

data/lib/graphql/list_type.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  # A list type modifies another type.
-  #
-  # List types can be created with the type helper (`types[InnerType]`)
-  # or {BaseType#to_list_type} (`InnerType.to_list_type`)
-  #
-  # For return types, it says that the returned value will be a list of the modified.
-  #
-  # @example A field which returns a list of items
-  #   field :items, types[ItemType]
-  #   # or
-  #   field :items, ItemType.to_list_type
-  #
-  # For input types, it says that the incoming value will be a list of the modified type.
-  #
-  # @example A field which accepts a list of strings
-  #   field :newNames do
-  #     # ...
-  #     argument :values, types[types.String]
-  #     # or
-  #     argument :values, types.String.to_list_type
-  #   end
-  #
-  # Given a list type, you can always get the underlying type with {#unwrap}.
-  #
-  class ListType < GraphQL::BaseType
-    include GraphQL::BaseType::ModifiesAnotherType
-    attr_reader :of_type
-    def initialize(of_type:)
-      super()
-      @of_type = of_type
-    end
-
-    def kind
-      GraphQL::TypeKinds::LIST
-    end
-
-    def to_s
-      "[#{of_type.to_s}]"
-    end
-    alias_method :inspect, :to_s
-    alias :to_type_signature :to_s
-
-    def coerce_result(value, ctx = nil)
-      if ctx.nil?
-        warn_deprecated_coerce("coerce_isolated_result")
-        ctx = GraphQL::Query::NullContext
-      end
-      ensure_array(value).map { |item| item.nil? ? nil : of_type.coerce_result(item, ctx) }
-    end
-
-    def list?
-      true
-    end
-
-    private
-
-    def coerce_non_null_input(value, ctx)
-      ensure_array(value).map { |item| of_type.coerce_input(item, ctx) }
-    end
-
-    def validate_non_null_input(value, ctx)
-      result = GraphQL::Query::InputValidationResult.new
-
-      ensure_array(value).each_with_index do |item, index|
-        item_result = of_type.validate_input(item, ctx)
-        if !item_result.valid?
-          result.merge_result!(index, item_result)
-        end
-      end
-
-      result
-    end
-
-    def ensure_array(value)
-      value.is_a?(Array) ? value : [value]
-    end
-  end
-end