graphql 1.13.17 → 2.0.20

data/lib/graphql/interface_type.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  # @api deprecated
-  class InterfaceType < GraphQL::BaseType
-    extend Define::InstanceDefinable::DeprecatedDefine
-
-    deprecated_accepts_definitions :fields, :orphan_types, :resolve_type, field: GraphQL::Define::AssignObjectField
-
-    attr_accessor :fields, :orphan_types, :resolve_type_proc
-    attr_writer :type_membership_class
-    ensure_defined :fields, :orphan_types, :resolve_type_proc, :resolve_type
-
-    def initialize
-      super
-      @fields = {}
-      @orphan_types = []
-      @resolve_type_proc = nil
-    end
-
-    def initialize_copy(other)
-      super
-      @fields = other.fields.dup
-      @orphan_types = other.orphan_types.dup
-    end
-
-    def kind
-      GraphQL::TypeKinds::INTERFACE
-    end
-
-    def resolve_type(value, ctx)
-      ctx.query.resolve_type(self, value)
-    end
-
-    def resolve_type=(resolve_type_callable)
-      @resolve_type_proc = resolve_type_callable
-    end
-
-    # @return [GraphQL::Field] The defined field for `field_name`
-    def get_field(field_name)
-      fields[field_name]
-    end
-
-    # These fields don't have instrumenation applied
-    # @see [Schema#get_fields] Get fields with instrumentation
-    # @return [Array<GraphQL::Field>] All fields on this type
-    def all_fields
-      fields.values
-    end
-
-    # Get a possible type of this {InterfaceType} by type name
-    # @param type_name [String]
-    # @param ctx [GraphQL::Query::Context] The context for the current query
-    # @return [GraphQL::ObjectType, nil] The type named `type_name` if it exists and implements this {InterfaceType}, (else `nil`)
-    def get_possible_type(type_name, ctx)
-      type = ctx.query.get_type(type_name)
-      type if type && ctx.query.warden.possible_types(self).include?(type)
-    end
-
-    # Check if a type is a possible type of this {InterfaceType}
-    # @param type [String, GraphQL::BaseType] Name of the type or a type definition
-    # @param ctx [GraphQL::Query::Context] The context for the current query
-    # @return [Boolean] True if the `type` exists and is a member of this {InterfaceType}, (else `nil`)
-    def possible_type?(type, ctx)
-      type_name = type.is_a?(String) ? type : type.graphql_name
-      !get_possible_type(type_name, ctx).nil?
-    end
-
-    def type_membership_class
-      @type_membership_class || GraphQL::Schema::TypeMembership
-    end
-  end
-end

data/lib/graphql/internal_representation/document.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module InternalRepresentation
-    class Document
-      # @return [Hash<String, Node>] Operation Nodes of this query
-      attr_reader :operation_definitions
-
-      # @return [Hash<String, Node>] Fragment definition Nodes of this query
-      attr_reader :fragment_definitions
-
-      def initialize
-        @operation_definitions = {}
-        @fragment_definitions = {}
-      end
-
-      def [](key)
-        GraphQL::Deprecation.warn "#{self.class}#[] is deprecated; use `operation_definitions[]` instead"
-        operation_definitions[key]
-      end
-
-      def each(&block)
-        GraphQL::Deprecation.warn "#{self.class}#each is deprecated; use `operation_definitions.each` instead"
-        operation_definitions.each(&block)
-      end
-    end
-  end
-end

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"