graphql 1.9.21 → 2.0.0

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
-        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
-        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

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)
-        yield(node)
-        node.typed_children.each do |obj_type, children|
-          children.each do |name, node|
-            each_node(node) { |n| yield(n) }
-          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

data/lib/graphql/literal_validation_error.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class LiteralValidationError < GraphQL::Error
-    attr_accessor :ast_value
-  end
-end

data/lib/graphql/non_null_type.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class DoubleNonNullTypeError < GraphQL::Error
-  end
-
-  # A non-null type modifies another type.
-  #
-  # Non-null types can be created with `!` (`InnerType!`)
-  # or {BaseType#to_non_null_type} (`InnerType.to_non_null_type`)
-  #
-  # For return types, it says that the returned value will _always_ be present.
-  #
-  # @example A field which _always_ returns an error
-  #   field :items, !ItemType
-  #   # or
-  #   field :items, ItemType.to_non_null_type
-  #
-  # (If the application fails to return a value, {InvalidNullError} will be passed to {Schema#type_error}.)
-  #
-  # For input types, it says that the incoming value _must_ be provided by the query.
-  #
-  # @example A field which _requires_ a string input
-  #   field :newNames do
-  #     # ...
-  #     argument :values, !types.String
-  #     # or
-  #     argument :values, types.String.to_non_null_type
-  #   end
-  #
-  # (If a value isn't provided, {Query::VariableValidationError} will be raised).
-  #
-  # Given a non-null type, you can always get the underlying type with {#unwrap}.
-  #
-  class NonNullType < GraphQL::BaseType
-    include GraphQL::BaseType::ModifiesAnotherType
-    extend Forwardable
-
-    attr_reader :of_type
-    def initialize(of_type:)
-      if of_type.is_a?(GraphQL::NonNullType)
-        raise(
-          DoubleNonNullTypeError,
-          "You tried to add a non-null constraint twice (!! instead of !)"
-        )
-      end
-
-      super()
-      @of_type = of_type
-    end
-
-    def valid_input?(value, ctx)
-      validate_input(value, ctx).valid?
-    end
-
-    def validate_input(value, ctx)
-      if value.nil?
-        result = GraphQL::Query::InputValidationResult.new
-        result.add_problem("Expected value to not be null")
-        result
-      else
-        of_type.validate_input(value, ctx)
-      end
-    end
-
-    def_delegators :@of_type, :coerce_input, :coerce_result, :list?
-
-    def kind
-      GraphQL::TypeKinds::NON_NULL
-    end
-
-    def to_s
-      "#{of_type.to_s}!"
-    end
-    alias_method :inspect, :to_s
-    alias :to_type_signature :to_s
-
-    def non_null?
-      true
-    end
-  end
-end

data/lib/graphql/object_type.rb

@@ -1,141 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  # This type exposes fields on an object.
-  #
-  # @example defining a type for your IMDB clone
-  #   MovieType = GraphQL::ObjectType.define do
-  #     name "Movie"
-  #     description "A full-length film or a short film"
-  #     interfaces [ProductionInterface, DurationInterface]
-  #
-  #     field :runtimeMinutes, !types.Int, property: :runtime_minutes
-  #     field :director, PersonType
-  #     field :cast, CastType
-  #     field :starring, types[PersonType] do
-  #       argument :limit, types.Int
-  #       resolve ->(object, args, ctx) {
-  #         stars = object.cast.stars
-  #         args[:limit] && stars = stars.limit(args[:limit])
-  #         stars
-  #       }
-  #      end
-  #   end
-  #
-  class ObjectType < GraphQL::BaseType
-    accepts_definitions :interfaces, :fields, :mutation, :relay_node_type, field: GraphQL::Define::AssignObjectField
-    accepts_definitions implements: ->(type, *interfaces, inherit: false) { type.implements(interfaces, inherit: inherit) }
-
-    attr_accessor :fields, :mutation, :relay_node_type
-    ensure_defined(:fields, :mutation, :interfaces, :relay_node_type)
-
-    # @!attribute fields
-    #   @return [Hash<String => GraphQL::Field>] Map String fieldnames to their {GraphQL::Field} implementations
-
-    # @!attribute mutation
-    #   @return [GraphQL::Relay::Mutation, nil] The mutation this object type was derived from, if it is an auto-generated payload type.
-
-    def initialize
-      super
-      @fields = {}
-      @interface_fields = {}
-      @dirty_interfaces = []
-      @dirty_inherited_interfaces = []
-    end
-
-    def initialize_copy(other)
-      super
-      @clean_interfaces = nil
-      @clean_inherited_interfaces = nil
-      @dirty_interfaces = other.dirty_interfaces.dup
-      @dirty_inherited_interfaces = other.dirty_inherited_interfaces.dup
-      @fields = other.fields.dup
-    end
-
-    # This method declares interfaces for this type AND inherits any field definitions
-    # @param new_interfaces [Array<GraphQL::Interface>] interfaces that this type implements
-    # @deprecated Use `implements` instead of `interfaces`.
-    def interfaces=(new_interfaces)
-      @clean_interfaces = nil
-      @clean_inherited_interfaces = nil
-      @clean_inherited_fields = nil
-
-      @dirty_inherited_interfaces = []
-      @dirty_inherited_fields = {}
-      implements(new_interfaces, inherit: true)
-    end
-
-    def interfaces
-      load_interfaces
-      @clean_interfaces
-    end
-
-    def kind
-      GraphQL::TypeKinds::OBJECT
-    end
-
-    # This fields doesnt have instrumenation applied
-    # @see [Schema#get_field] Get field with instrumentation
-    # @return [GraphQL::Field] The field definition for `field_name` (may be inherited from interfaces)
-    def get_field(field_name)
-      fields[field_name] || interface_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, including ones inherited from interfaces
-    def all_fields
-      interface_fields.merge(self.fields).values
-    end
-
-    # Declare that this object implements this interface.
-    # This declaration will be validated when the schema is defined.
-    # @param interfaces [Array<GraphQL::Interface>] add a new interface that this type implements
-    # @param inherits [Boolean] If true, copy the interfaces' field definitions to this type
-    def implements(interfaces, inherit: false)
-      if !interfaces.is_a?(Array)
-        raise ArgumentError, "`implements(interfaces)` must be an array, not #{interfaces.class} (#{interfaces})"
-      end
-
-      @clean_interfaces = nil
-      @clean_inherited_fields = nil
-      dirty_ifaces = inherit ? @dirty_inherited_interfaces : @dirty_interfaces
-      dirty_ifaces.concat(interfaces)
-    end
-
-    def resolve_type_proc
-      nil
-    end
-
-    protected
-
-    attr_reader :dirty_interfaces, :dirty_inherited_interfaces
-
-    private
-
-    def normalize_interfaces(ifaces)
-      ifaces.map { |i_type| GraphQL::BaseType.resolve_related_type(i_type) }
-    end
-
-    def interface_fields
-      load_interfaces
-      @clean_inherited_fields
-    end
-
-    def load_interfaces
-      @clean_interfaces ||= begin
-        ensure_defined
-        clean_ifaces = normalize_interfaces(@dirty_interfaces)
-        clean_inherited_ifaces = normalize_interfaces(@dirty_inherited_interfaces)
-        inherited_fields = {}
-        clean_inherited_ifaces.each do |iface|
-          # This will be found later in schema validation:
-          if iface.is_a?(GraphQL::InterfaceType)
-            inherited_fields.merge!(iface.fields)
-          end
-        end
-        @clean_inherited_fields = inherited_fields
-        clean_inherited_ifaces + clean_ifaces
-      end
-    end
-  end
-end