graphql 1.8.0 → 1.12.12

data/lib/graphql/interface_type.rb

@@ -1,31 +1,13 @@
 # frozen_string_literal: true
 module GraphQL
-  # An Interface contains a collection of types which implement some of the same fields.
-  #
-  # Interfaces can have fields, defined with `field`, just like an object type.
-  #
-  # Objects which implement this field _inherit_ field definitions from the interface.
-  # An object type can override the inherited definition by redefining that field.
-  #
-  # @example An interface with three fields
-  #   DeviceInterface = GraphQL::InterfaceType.define do
-  #     name("Device")
-  #     description("Hardware devices for computing")
-  #
-  #     field :ram, types.String
-  #     field :processor, ProcessorType
-  #     field :release_year, types.Int
-  #   end
-  #
-  # @example Implementing an interface with an object type
-  #   Laptoptype = GraphQL::ObjectType.define do
-  #     interfaces [DeviceInterface]
-  #   end
-  #
+  # @api deprecated
   class InterfaceType < GraphQL::BaseType
+    extend Define::InstanceDefinable::DeprecatedDefine
+
     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
@@ -64,5 +46,27 @@ module GraphQL
     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

@@ -14,12 +14,12 @@ module GraphQL
       end
 
       def [](key)
-        warn "#{self.class}#[] is deprecated; use `operation_definitions[]` instead"
+        GraphQL::Deprecation.warn "#{self.class}#[] is deprecated; use `operation_definitions[]` instead"
         operation_definitions[key]
       end
 
       def each(&block)
-        warn "#{self.class}#each is deprecated; use `operation_definitions.each` instead"
+        GraphQL::Deprecation.warn "#{self.class}#each is deprecated; use `operation_definitions.each` instead"
         operation_definitions.each(&block)
       end
     end

data/lib/graphql/internal_representation/rewrite.rb

@@ -13,127 +13,29 @@ module GraphQL
     #
     # The rewritten query tree serves as the basis for the `FieldsWillMerge` validation.
     #
-    class Rewrite
+    module Rewrite
       include GraphQL::Language
 
       NO_DIRECTIVES = [].freeze
 
       # @return InternalRepresentation::Document
-      attr_reader :document
+      attr_reader :rewrite_document
 
-      def initialize
-        @document = InternalRepresentation::Document.new
-      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 validate(context)
-        visitor = context.visitor
-        query = context.query
+      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
-        spread_parents = Hash.new { |h, k| h[k] = Set.new }
+        @rewrite_spread_parents = Hash.new { |h, k| h[k] = Set.new }
         # Hash<Nodes::FragmentSpread => Scope>
-        spread_scopes = {}
+        @rewrite_spread_scopes = {}
         # Array<Set<InternalRepresentation::Node>>
         # The current point of the irep_tree during visitation
-        nodes_stack = []
+        @rewrite_nodes_stack = []
         # Array<Scope>
-        scopes_stack = []
-
-        skip_nodes = Set.new
-
-        visit_op = VisitDefinition.new(context, @document.operation_definitions, 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, @document.fragment_definitions, nodes_stack, scopes_stack)
-        visitor[Nodes::FragmentDefinition].enter << visit_frag.method(:enter)
-        visitor[Nodes::FragmentDefinition].leave << visit_frag.method(:leave)
-
-        visitor[Nodes::InlineFragment].enter << ->(ast_node, ast_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?(ast_node, query)
-            skip_nodes.add(ast_node)
-          end
-
-          if skip_nodes.none?
-            scopes_stack.push(scopes_stack.last.enter(context.type_definition))
-          end
-        }
-
-        visitor[Nodes::InlineFragment].leave << ->(ast_node, ast_parent) {
-          if skip_nodes.none?
-            scopes_stack.pop
-          end
-
-          if skip_nodes.include?(ast_node)
-            skip_nodes.delete(ast_node)
-          end
-        }
-
-        visitor[Nodes::Field].enter << ->(ast_node, ast_parent) {
-          if skip?(ast_node, query)
-            skip_nodes.add(ast_node)
-          end
-
-          if skip_nodes.none?
-            node_name = ast_node.alias || ast_node.name
-            parent_nodes = 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
-              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
-
-            nodes_stack.push(next_nodes)
-            scopes_stack.push(new_scope)
-          end
-        }
-
-        visitor[Nodes::Field].leave << ->(ast_node, ast_parent) {
-          if skip_nodes.none?
-            nodes_stack.pop
-            scopes_stack.pop
-          end
-
-          if skip_nodes.include?(ast_node)
-            skip_nodes.delete(ast_node)
-          end
-        }
-
-        visitor[Nodes::FragmentSpread].enter << ->(ast_node, ast_parent) {
-          if skip_nodes.none? && !skip?(ast_node, query)
-            # Register the irep nodes that depend on this AST node:
-            spread_parents[ast_node].merge(nodes_stack.last)
-            spread_scopes[ast_node] = scopes_stack.last
-          end
-        }
+        @rewrite_scopes_stack = []
+        @rewrite_skip_nodes = Set.new
 
         # Resolve fragment spreads.
         # Fragment definitions got their own irep trees during visitation.
@@ -142,12 +44,12 @@ 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
-          fragment_node = @document.fragment_definitions[frag_name]
+          fragment_node = @rewrite_document.fragment_definitions[frag_name]
 
           if fragment_node
             spread_ast_nodes.each do |spread_ast_node|
-              parent_nodes = spread_parents[spread_ast_node]
-              parent_scope = spread_scopes[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
@@ -156,43 +58,126 @@ module GraphQL
         end
       end
 
-      def skip?(ast_node, query)
-        dir = ast_node.directives
-        dir.any? && !GraphQL::Execution::DirectiveChecks.include?(dir, query)
+      # @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
 
-      class VisitDefinition
-        def initialize(context, definitions, nodes_stack, scopes_stack)
-          @context = context
-          @query = context.query
-          @definitions = definitions
-          @nodes_stack = nodes_stack
-          @scopes_stack = scopes_stack
+      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
 
-        def enter(ast_node, ast_parent)
-          # Either QueryType or the fragment type condition
-          owner_type = @context.type_definition && @context.type_definition.unwrap
-          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: @context.type_definition,
-          )
-
-          @definitions[defn_name] = node
-          @scopes_stack.push(Scope.new(@query, owner_type))
-          @nodes_stack.push([node])
+        if @rewrite_skip_nodes.include?(node)
+          @rewrite_skip_nodes.delete(node)
         end
+      end
 
-        def leave(ast_node, ast_parent)
-          @nodes_stack.pop
-          @scopes_stack.pop
+      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

data/lib/graphql/internal_representation/scope.rb

@@ -66,11 +66,11 @@ module GraphQL
       # 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
+      def each(&block)
         if @abstract_type
           yield(@type)
         else
-          @types.each { |t| yield(t) }
+          @types.each(&block)
         end
       end
 

data/lib/graphql/internal_representation/visit.rb

@@ -5,6 +5,7 @@ module GraphQL
     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
@@ -22,11 +23,11 @@ module GraphQL
 
       # Traverse a node in a rewritten query tree,
       # visiting the node itself and each of its typed children.
-      def each_node(node)
+      def each_node(node, &block)
         yield(node)
         node.typed_children.each do |obj_type, children|
           children.each do |name, node|
-            each_node(node) { |n| yield(n) }
+            each_node(node, &block)
           end
         end
       end

data/lib/graphql/introspection/base_object.rb

@@ -2,15 +2,12 @@
 module GraphQL
   module Introspection
     class BaseObject < GraphQL::Schema::Object
+      introspection(true)
+
       def self.field(*args, **kwargs, &block)
         kwargs[:introspection] = true
         super(*args, **kwargs, &block)
       end
-
-      def self.inherited(child_class)
-        child_class.introspection(true)
-        super
-      end
     end
   end
 end

data/lib/graphql/introspection/directive_type.rb

@@ -9,16 +9,20 @@ module GraphQL
                   "in ways field arguments will not suffice, such as conditionally including or "\
                   "skipping a field. Directives provide this by describing additional information "\
                     "to the executor."
-      field :name, String, null: false
+      field :name, String, null: false, method: :graphql_name
       field :description, String, null: true
       field :locations, [GraphQL::Schema::LateBoundType.new("__DirectiveLocation")], null: false
-      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false
+      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false do
+        argument :include_deprecated, Boolean, required: false, default_value: false
+      end
       field :on_operation, Boolean, null: false, deprecation_reason: "Use `locations`.", method: :on_operation?
       field :on_fragment, Boolean, null: false, deprecation_reason: "Use `locations`.", method: :on_fragment?
       field :on_field, Boolean, null: false, deprecation_reason: "Use `locations`.", method: :on_field?
 
-      def args
-        @context.warden.arguments(@object)
+      def args(include_deprecated:)
+        args = @context.warden.arguments(@object)
+        args = args.reject(&:deprecation_reason) unless include_deprecated
+        args
       end
     end
   end

data/lib/graphql/introspection/dynamic_fields.rb

@@ -1,10 +1,16 @@
 # frozen_string_literal: true
 module GraphQL
   module Introspection
-    class DynamicFields < GraphQL::Schema::Object
+    class DynamicFields < Introspection::BaseObject
       field :__typename, String, "The name of this type", null: false, extras: [:irep_node]
-      def __typename(irep_node:)
-        irep_node.owner_type.name
+
+      # `irep_node:` will be nil for the interpreter, since there is no such thing
+      def __typename(irep_node: nil)
+        if context.interpreter?
+          object.class.graphql_name
+        else
+          irep_node.owner_type.name
+        end
       end
     end
   end

data/lib/graphql/introspection/entry_points.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 module GraphQL
   module Introspection
-    class EntryPoints < GraphQL::Schema::Object
+    class EntryPoints < Introspection::BaseObject
       field :__schema, GraphQL::Schema::LateBoundType.new("__Schema"), "This GraphQL schema", null: false
       field :__type, GraphQL::Schema::LateBoundType.new("__Type"), "A type in the GraphQL system", null: true do
         argument :name, String, required: true
@@ -10,19 +10,25 @@ module GraphQL
       def __schema
         # Apply wrapping manually since this field isn't wrapped by instrumentation
         schema = @context.query.schema
-        schema_type = schema.introspection_system.schema_type
-        schema_type.metadata[:type_class].new(schema, @context)
+        schema_type = schema.introspection_system.types["__Schema"]
+        schema_type.type_class.authorized_new(schema, @context)
       end
 
       def __type(name:)
-        type = @context.warden.get_type(name)
-        if type
+        return unless context.warden.reachable_type?(name)
+        type = context.warden.get_type(name)
+
+        if type && context.interpreter? && !type.is_a?(Module)
+          type = type.type_class || raise("Invariant: interpreter requires class-based type for #{name}")
+        end
+
+        # The interpreter provides this wrapping, other execution doesnt, so support both.
+        if type && !context.interpreter?
           # Apply wrapping manually since this field isn't wrapped by instrumentation
-          type_type = @context.schema.introspection_system.type_type
-          type_type.metadata[:type_class].new(type, @context)
-        else
-          nil
+          type_type = context.schema.introspection_system.types["__Type"]
+          type = type_type.type_class.authorized_new(type, context)
         end
+        type
       end
     end
   end

data/lib/graphql/introspection/enum_value_type.rb

@@ -11,6 +11,10 @@ module GraphQL
       field :is_deprecated, Boolean, null: false
       field :deprecation_reason, String, null: true
 
+      def name
+        object.graphql_name
+      end
+
       def is_deprecated
         !!@object.deprecation_reason
       end

data/lib/graphql/introspection/field_type.rb

@@ -7,7 +7,9 @@ module GraphQL
                   "a name, potentially a list of arguments, and a return type."
       field :name, String, null: false
       field :description, String, null: true
-      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false
+      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false do
+        argument :include_deprecated, Boolean, required: false, default_value: false
+      end
       field :type, GraphQL::Schema::LateBoundType.new("__Type"), null: false
       field :is_deprecated, Boolean, null: false
       field :deprecation_reason, String, null: true
@@ -16,8 +18,10 @@ module GraphQL
         !!@object.deprecation_reason
       end
 
-      def args
-        @context.warden.arguments(@object)
+      def args(include_deprecated:)
+        args = @context.warden.arguments(@object)
+        args = args.reject(&:deprecation_reason) unless include_deprecated
+        args
       end
     end
   end

data/lib/graphql/introspection/input_value_type.rb

@@ -10,6 +10,12 @@ module GraphQL
       field :description, String, null: true
       field :type, GraphQL::Schema::LateBoundType.new("__Type"), null: false
       field :default_value, String, "A GraphQL-formatted string representing the default value for this input value.", null: true
+      field :is_deprecated, Boolean, null: false
+      field :deprecation_reason, String, null: true
+
+      def is_deprecated
+        !!@object.deprecation_reason
+      end
 
       def default_value
         if @object.default_value?
@@ -18,16 +24,38 @@ module GraphQL
             'null'
           else
             coerced_default_value = @object.type.coerce_result(value, @context)
-            if @object.type.unwrap.is_a?(GraphQL::EnumType)
-              coerced_default_value
-            else
-              GraphQL::Language.serialize(coerced_default_value)
-            end
+            serialize_default_value(coerced_default_value, @object.type)
           end
         else
           nil
         end
       end
+
+
+      private
+
+      # Recursively serialize, taking care not to add quotes to enum values
+      def serialize_default_value(value, type)
+        if value.nil?
+          'null'
+        elsif type.kind.list?
+          inner_type = type.of_type
+          "[" + value.map { |v| serialize_default_value(v, inner_type) }.join(", ") + "]"
+        elsif type.kind.non_null?
+          serialize_default_value(value, type.of_type)
+        elsif type.kind.enum?
+          value
+        elsif type.kind.input_object?
+          "{" +
+            value.map do |k, v|
+              arg_defn = type.arguments[k]
+              "#{k}: #{serialize_default_value(v, arg_defn.type)}"
+            end.join(", ") +
+            "}"
+        else
+          GraphQL::Language.serialize(value)
+        end
+      end
     end
   end
 end