graphql 2.3.5 → 2.3.14

data/lib/graphql/execution/lookahead.rb

@@ -108,16 +108,16 @@ module GraphQL
       def selection(field_name, selected_type: @selected_type, arguments: nil)
         next_field_defn = case field_name
         when String
-          @query.get_field(selected_type, field_name)
+          @query.types.field(selected_type, field_name)
         when Symbol
           # Try to avoid the `.to_s` below, if possible
           all_fields = if selected_type.kind.fields?
-            @query.warden.fields(selected_type)
+            @query.types.fields(selected_type)
           else
             # Handle unions by checking possible
-            @query.warden
+            @query.types
               .possible_types(selected_type)
-              .map { |t| @query.warden.fields(t) }
+              .map { |t| @query.types.fields(t) }
               .tap(&:flatten!)
           end
 
@@ -128,7 +128,7 @@ module GraphQL
             # Symbol#name is only present on 3.0+
             sym_s = field_name.respond_to?(:name) ? field_name.name : field_name.to_s
             guessed_name = Schema::Member::BuildType.camelize(sym_s)
-            @query.get_field(selected_type, guessed_name)
+            @query.types.field(selected_type, guessed_name)
           end
         end
         lookahead_for_selection(next_field_defn, selected_type, arguments)
@@ -144,7 +144,7 @@ module GraphQL
         alias_node = lookup_alias_node(ast_nodes, alias_name)
         return NULL_LOOKAHEAD unless alias_node
 
-        next_field_defn = @query.get_field(selected_type, alias_node.name)
+        next_field_defn = @query.types.field(selected_type, alias_node.name)
 
         alias_arguments = @query.arguments_for(alias_node, next_field_defn)
         if alias_arguments.is_a?(::GraphQL::Execution::Interpreter::Arguments)
@@ -183,7 +183,7 @@ module GraphQL
 
         subselections_by_type.each do |type, ast_nodes_by_response_key|
           ast_nodes_by_response_key.each do |response_key, ast_nodes|
-            field_defn = @query.get_field(type, ast_nodes.first.name)
+            field_defn = @query.types.field(type, ast_nodes.first.name)
             lookahead = Lookahead.new(query: @query, ast_nodes: ast_nodes, field: field_defn, owner_type: type)
             subselections.push(lookahead)
           end
@@ -266,7 +266,7 @@ module GraphQL
             elsif arguments.nil? || arguments.empty?
               selections_on_type[response_key] = [ast_selection]
             else
-              field_defn = @query.get_field(selected_type, ast_selection.name)
+              field_defn = @query.types.field(selected_type, ast_selection.name)
               if arguments_match?(arguments, field_defn, ast_selection)
                 selections_on_type[response_key] = [ast_selection]
               end
@@ -276,14 +276,14 @@ module GraphQL
             subselections_on_type = selections_on_type
             if (t = ast_selection.type)
               # Assuming this is valid, that `t` will be found.
-              on_type = @query.get_type(t.name)
+              on_type = @query.types.type(t.name)
               subselections_on_type = subselections_by_type[on_type] ||= {}
             end
             find_selections(subselections_by_type, subselections_on_type, on_type, ast_selection.selections, arguments)
           when GraphQL::Language::Nodes::FragmentSpread
             frag_defn = lookup_fragment(ast_selection)
             # Again, assuming a valid AST
-            on_type = @query.get_type(frag_defn.type.name)
+            on_type = @query.types.type(frag_defn.type.name)
             subselections_on_type = subselections_by_type[on_type] ||= {}
             find_selections(subselections_by_type, subselections_on_type, on_type, frag_defn.selections, arguments)
           else

data/lib/graphql/introspection/directive_type.rb

@@ -22,7 +22,7 @@ module GraphQL
       field :is_repeatable, Boolean, method: :repeatable?
 
       def args(include_deprecated:)
-        args = @context.warden.arguments(@object)
+        args = @context.types.arguments(@object)
         args = args.reject(&:deprecation_reason) unless include_deprecated
         args
       end

data/lib/graphql/introspection/entry_points.rb

@@ -15,8 +15,8 @@ module GraphQL
       end
 
       def __type(name:)
-        if context.warden.reachable_type?(name)
-          context.warden.get_type(name)
+        if context.types.reachable_type?(name) && (type = context.types.type(name))
+          type
         elsif (type = context.schema.extra_types.find { |t| t.graphql_name == name })
           type
         else

data/lib/graphql/introspection/field_type.rb

@@ -19,7 +19,7 @@ module GraphQL
       end
 
       def args(include_deprecated:)
-        args = @context.warden.arguments(@object)
+        args = @context.types.arguments(@object)
         args = args.reject(&:deprecation_reason) unless include_deprecated
         args
       end

data/lib/graphql/introspection/schema_type.rb

@@ -20,31 +20,26 @@ module GraphQL
       end
 
       def types
-        types = context.warden.reachable_types + context.schema.extra_types
+        query_types = context.types.all_types
+        types = query_types + context.schema.extra_types
         types.sort_by!(&:graphql_name)
         types
       end
 
       def query_type
-        permitted_root_type("query")
+        @context.types.query_root
       end
 
       def mutation_type
-        permitted_root_type("mutation")
+        @context.types.mutation_root
       end
 
       def subscription_type
-        permitted_root_type("subscription")
+        @context.types.subscription_root
       end
 
       def directives
-        @context.warden.directives
-      end
-
-      private
-
-      def permitted_root_type(op_type)
-        @context.warden.root_type_for_operation(op_type)
+        @context.types.directives.sort_by(&:graphql_name)
       end
     end
   end

data/lib/graphql/introspection/type_type.rb

@@ -52,7 +52,7 @@ module GraphQL
         if !@object.kind.enum?
           nil
         else
-          enum_values = @context.warden.enum_values(@object)
+          enum_values = @context.types.enum_values(@object)
 
           if !include_deprecated
             enum_values = enum_values.select {|f| !f.deprecation_reason }
@@ -64,7 +64,7 @@ module GraphQL
 
       def interfaces
         if @object.kind.object? || @object.kind.interface?
-          @context.warden.interfaces(@object).sort_by(&:graphql_name)
+          @context.types.interfaces(@object).sort_by(&:graphql_name)
         else
           nil
         end
@@ -72,7 +72,7 @@ module GraphQL
 
       def input_fields(include_deprecated:)
         if @object.kind.input_object?
-          args = @context.warden.arguments(@object)
+          args = @context.types.arguments(@object)
           args = args.reject(&:deprecation_reason) unless include_deprecated
           args
         else
@@ -82,7 +82,7 @@ module GraphQL
 
       def possible_types
         if @object.kind.abstract?
-          @context.warden.possible_types(@object).sort_by(&:graphql_name)
+          @context.types.possible_types(@object).sort_by(&:graphql_name)
         else
           nil
         end
@@ -92,7 +92,7 @@ module GraphQL
         if !@object.kind.fields?
           nil
         else
-          fields = @context.warden.fields(@object)
+          fields = @context.types.fields(@object)
           if !include_deprecated
             fields = fields.select {|f| !f.deprecation_reason }
           end

data/lib/graphql/language/document_from_schema_definition.rb

@@ -24,15 +24,8 @@ module GraphQL
         @include_built_in_directives = include_built_in_directives
         @include_one_of = false
 
-        schema_context = schema.context_class.new(query: nil, schema: schema, values: context)
-
-
-        @warden = @schema.warden_class.new(
-          schema: @schema,
-          context: schema_context,
-        )
-
-        schema_context.warden = @warden
+        dummy_query = @schema.query_class.new(@schema, "{ __typename }", validate: false, context: context)
+        @types = dummy_query.types # rubocop:disable Development/ContextIsPassedCop
       end
 
       def document
@@ -44,9 +37,9 @@ module GraphQL
       def build_schema_node
         if !schema_respects_root_name_conventions?(@schema)
           GraphQL::Language::Nodes::SchemaDefinition.new(
-            query: (q = warden.root_type_for_operation("query")) && q.graphql_name,
-            mutation: (m = warden.root_type_for_operation("mutation")) && m.graphql_name,
-            subscription: (s = warden.root_type_for_operation("subscription")) && s.graphql_name,
+            query:  @types.query_root&.graphql_name,
+            mutation: @types.mutation_root&.graphql_name,
+            subscription: @types.subscription_root&.graphql_name,
             directives: definition_directives(@schema, :schema_directives)
           )
         else
@@ -57,7 +50,7 @@ module GraphQL
       end
 
       def build_object_type_node(object_type)
-        ints = warden.interfaces(object_type)
+        ints = @types.interfaces(object_type)
         if ints.any?
           ints.sort_by!(&:graphql_name)
           ints.map! { |iface| build_type_name_node(iface) }
@@ -66,7 +59,7 @@ module GraphQL
         GraphQL::Language::Nodes::ObjectTypeDefinition.new(
           name: object_type.graphql_name,
           interfaces: ints,
-          fields: build_field_nodes(warden.fields(object_type)),
+          fields: build_field_nodes(@types.fields(object_type)),
           description: object_type.description,
           directives: directives(object_type),
         )
@@ -75,7 +68,7 @@ module GraphQL
       def build_field_node(field)
         GraphQL::Language::Nodes::FieldDefinition.new(
           name: field.graphql_name,
-          arguments: build_argument_nodes(warden.arguments(field)),
+          arguments: build_argument_nodes(@types.arguments(field)),
           type: build_type_name_node(field.type),
           description: field.description,
           directives: directives(field),
@@ -86,7 +79,7 @@ module GraphQL
         GraphQL::Language::Nodes::UnionTypeDefinition.new(
           name: union_type.graphql_name,
           description: union_type.description,
-          types: warden.possible_types(union_type).sort_by(&:graphql_name).map { |type| build_type_name_node(type) },
+          types: @types.possible_types(union_type).sort_by(&:graphql_name).map { |type| build_type_name_node(type) },
           directives: directives(union_type),
         )
       end
@@ -94,9 +87,9 @@ module GraphQL
       def build_interface_type_node(interface_type)
         GraphQL::Language::Nodes::InterfaceTypeDefinition.new(
           name: interface_type.graphql_name,
-          interfaces: warden.interfaces(interface_type).sort_by(&:graphql_name).map { |type| build_type_name_node(type) },
+          interfaces: @types.interfaces(interface_type).sort_by(&:graphql_name).map { |type| build_type_name_node(type) },
           description: interface_type.description,
-          fields: build_field_nodes(warden.fields(interface_type)),
+          fields: build_field_nodes(@types.fields(interface_type)),
           directives: directives(interface_type),
         )
       end
@@ -104,7 +97,7 @@ module GraphQL
       def build_enum_type_node(enum_type)
         GraphQL::Language::Nodes::EnumTypeDefinition.new(
           name: enum_type.graphql_name,
-          values: warden.enum_values(enum_type).sort_by(&:graphql_name).map do |enum_value|
+          values: @types.enum_values(enum_type).sort_by(&:graphql_name).map do |enum_value|
             build_enum_value_node(enum_value)
           end,
           description: enum_type.description,
@@ -149,7 +142,7 @@ module GraphQL
       def build_input_object_node(input_object)
         GraphQL::Language::Nodes::InputObjectTypeDefinition.new(
           name: input_object.graphql_name,
-          fields: build_argument_nodes(warden.arguments(input_object)),
+          fields: build_argument_nodes(@types.arguments(input_object)),
           description: input_object.description,
           directives: directives(input_object),
         )
@@ -159,7 +152,7 @@ module GraphQL
         GraphQL::Language::Nodes::DirectiveDefinition.new(
           name: directive.graphql_name,
           repeatable: directive.repeatable?,
-          arguments: build_argument_nodes(warden.arguments(directive)),
+          arguments: build_argument_nodes(@types.arguments(directive)),
           locations: build_directive_location_nodes(directive.locations),
           description: directive.description,
         )
@@ -204,7 +197,7 @@ module GraphQL
         when "INPUT_OBJECT"
           GraphQL::Language::Nodes::InputObject.new(
             arguments: default_value.to_h.map do |arg_name, arg_value|
-              args = @warden.arguments(type)
+              args = @types.arguments(type)
               arg = args.find { |a| a.keyword.to_s == arg_name.to_s }
               if arg.nil?
                 raise ArgumentError, "No argument definition on #{type.graphql_name} for argument: #{arg_name.inspect} (expected one of: #{args.map(&:keyword)})"
@@ -260,13 +253,13 @@ module GraphQL
       end
 
       def build_definition_nodes
-        dirs_to_build = warden.directives
+        dirs_to_build = @types.directives
         if !include_built_in_directives
           dirs_to_build = dirs_to_build.reject { |directive| directive.default_directive? }
         end
         definitions = build_directive_nodes(dirs_to_build)
-
-        type_nodes = build_type_definition_nodes(warden.reachable_types + schema.extra_types)
+        all_types = @types.all_types
+        type_nodes = build_type_definition_nodes(all_types + schema.extra_types)
         if @include_one_of
           # This may have been set to true when iterating over all types
           definitions.concat(build_directive_nodes([GraphQL::Schema::Directive::OneOf]))
@@ -351,7 +344,7 @@ module GraphQL
         dirs
       end
 
-      attr_reader :schema, :warden, :always_include_schema,
+      attr_reader :schema, :always_include_schema,
         :include_introspection_types, :include_built_in_directives, :include_built_in_scalars
     end
   end

data/lib/graphql/language/lexer.rb

@@ -345,17 +345,14 @@ module GraphQL
       def self.tokenize(string)
         lexer = GraphQL::Language::Lexer.new(string)
         tokens = []
-        prev_token = nil
         while (token_name = lexer.advance)
           new_token = [
             token_name,
             lexer.line_number,
             lexer.column_number,
             lexer.debug_token_value(token_name),
-            prev_token,
           ]
           tokens << new_token
-          prev_token = new_token
         end
         tokens
       end

data/lib/graphql/language/nodes.rb

@@ -34,11 +34,11 @@ module GraphQL
         attr_reader :filename
 
         def line
-          @line ||= @source.line_at(@pos)
+          @line ||= @source&.line_at(@pos)
         end
 
         def col
-          @col ||= @source.column_at(@pos)
+          @col ||= @source&.column_at(@pos)
         end
 
         def definition_line

data/lib/graphql/language/parser.rb

@@ -141,7 +141,12 @@ module GraphQL
             parse_operation_type
           end
 
-          op_name = at?(:IDENTIFIER) ? parse_name : nil
+          op_name = case token_name
+          when :LPAREN, :LCURLY, :DIR_SIGN
+            nil
+          else
+            parse_name
+          end
 
           variable_definitions = if at?(:LPAREN)
             expect_token(:LPAREN)
@@ -398,6 +403,9 @@ module GraphQL
       def parse_union_members
         if at?(:EQUALS)
           expect_token :EQUALS
+          if at?(:PIPE)
+            advance_token
+          end
           list = [parse_type_name]
           while at?(:PIPE)
             advance_token

data/lib/graphql/language/sanitized_printer.rb

@@ -113,7 +113,7 @@ module GraphQL
       end
 
       def print_field(field, indent: "")
-        @current_field = query.get_field(@current_type, field.name)
+        @current_field = query.types.field(@current_type, field.name)
         old_type = @current_type
         @current_type = @current_field.type.unwrap
         super

data/lib/graphql/language.rb

@@ -9,7 +9,6 @@ require "graphql/language/nodes"
 require "graphql/language/cache"
 require "graphql/language/parser"
 require "graphql/language/static_visitor"
-require "graphql/language/token"
 require "graphql/language/visitor"
 require "graphql/language/definition_slice"
 require "strscan"

data/lib/graphql/query/context.rb

@@ -82,7 +82,13 @@ module GraphQL
         @provided_values[key] = value
       end
 
-      def_delegators :@query, :trace, :interpreter?
+      def_delegators :@query, :trace
+
+      def types
+        @types ||= @query.types
+      end
+
+      attr_writer :types
 
       RUNTIME_METADATA_KEYS = Set.new([:current_object, :current_arguments, :current_field, :current_path])
       # @!method []=(key, value)

data/lib/graphql/query/null_context.rb

@@ -27,8 +27,8 @@ module GraphQL
         @warden = Schema::Warden::NullWarden.new(context: self, schema: @schema)
       end
 
-      def interpreter?
-        true
+      def types
+        @types ||= GraphQL::Schema::Warden::SchemaSubset.new(@warden)
       end
     end
   end

data/lib/graphql/query/validation_pipeline.rb

@@ -100,10 +100,10 @@ module GraphQL
           # Depending on the analysis engine, we must use different analyzers
           # remove this once everything has switched over to AST analyzers
           if max_depth
-            qa << GraphQL::Analysis::AST::MaxQueryDepth
+            qa << GraphQL::Analysis::MaxQueryDepth
           end
           if max_complexity
-            qa << GraphQL::Analysis::AST::MaxQueryComplexity
+            qa << GraphQL::Analysis::MaxQueryComplexity
           end
           qa
         else

data/lib/graphql/query.rb

@@ -95,12 +95,24 @@ module GraphQL
     # @param root_value [Object] the object used to resolve fields on the root type
     # @param max_depth [Numeric] the maximum number of nested selections allowed for this query (falls back to schema-level value)
     # @param max_complexity [Numeric] the maximum field complexity for this query (falls back to schema-level value)
-    def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: nil, validate: true, static_validator: nil, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: schema.max_depth, max_complexity: schema.max_complexity, warden: nil)
+    def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: nil, validate: true, static_validator: nil, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: schema.max_depth, max_complexity: schema.max_complexity, warden: nil, use_schema_subset: nil)
       # Even if `variables: nil` is passed, use an empty hash for simpler logic
       variables ||= {}
       @schema = schema
       @context = schema.context_class.new(query: self, values: context)
-      @warden = warden
+
+      if use_schema_subset.nil?
+        use_schema_subset = warden ? false : schema.use_schema_subset?
+      end
+
+      if use_schema_subset
+        @schema_subset = @schema.subset_class.new(context: @context, schema: @schema)
+        @warden = Schema::Warden::NullWarden.new(context: @context, schema: @schema)
+      else
+        @schema_subset = nil
+        @warden = warden
+      end
+
       @subscription_topic = subscription_topic
       @root_value = root_value
       @fragments = nil
@@ -175,10 +187,6 @@ module GraphQL
       @query_string ||= (document ? document.to_query_string : nil)
     end
 
-    def interpreter?
-      true
-    end
-
     attr_accessor :multiplex
 
     # @return [GraphQL::Tracing::Trace]
@@ -195,7 +203,14 @@ module GraphQL
     def lookahead
       @lookahead ||= begin
         ast_node = selected_operation
-        root_type = warden.root_type_for_operation(ast_node.operation_type || "query")
+        root_type = case ast_node.operation_type
+        when nil, "query"
+          types.query_root # rubocop:disable Development/ContextIsPassedCop
+        when "mutation"
+          types.mutation_root # rubocop:disable Development/ContextIsPassedCop
+        when "subscription"
+          types.subscription_root # rubocop:disable Development/ContextIsPassedCop
+        end
         GraphQL::Execution::Lookahead.new(query: self, root_type: root_type, ast_nodes: [ast_node])
       end
     end
@@ -330,6 +345,10 @@ module GraphQL
 
     def_delegators :warden, :get_type, :get_field, :possible_types, :root_type_for_operation
 
+    def types
+      @schema_subset || warden.schema_subset
+    end
+
     # @param abstract_type [GraphQL::UnionType, GraphQL::InterfaceType]
     # @param value [Object] Any runtime value
     # @return [GraphQL::ObjectType, nil] The runtime type of `value` from {Schema#resolve_type}

data/lib/graphql/rubocop/graphql/field_type_in_block.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+require_relative "./base_cop"
+
+module GraphQL
+  module Rubocop
+    module GraphQL
+      # Identify (and auto-correct) any field whose type configuration isn't given
+      # in the configuration block.
+      #
+      # @example
+      #   # bad, immediately causes Rails to load `app/graphql/types/thing.rb`
+      #   field :thing, Types::Thing
+      #
+      #   # good, defers loading until the file is needed
+      #   field :thing do
+      #     type(Types::Thing)
+      #   end
+      #
+      class FieldTypeInBlock < BaseCop
+        MSG = "type configuration can be moved to a block to defer loading the type's file"
+
+        BUILT_IN_SCALAR_NAMES = ["Float", "Int", "Integer", "String", "ID", "Boolean"]
+        def_node_matcher :field_config_with_inline_type, <<-Pattern
+        (
+          send {nil? _} :field sym ${const array} ...
+        )
+        Pattern
+
+        def_node_matcher :field_config_with_inline_type_and_block, <<-Pattern
+        (
+          block
+            (send {nil? _} :field sym ${const array}) ...
+            (args)
+            _
+
+        )
+        Pattern
+
+        def on_block(node)
+          field_config_with_inline_type_and_block(node) do |type_const|
+            ignore_node(type_const)
+            type_const_str = get_type_argument_str(node, type_const)
+            if ignore_inline_type_str?(type_const_str)
+              # Do nothing ...
+            else
+              add_offense(type_const) do |corrector|
+                cleaned_node_source = delete_type_argument(node, type_const)
+                field_indent = determine_field_indent(node)
+                cleaned_node_source.sub!(/(\{|do)/, "\\1\n#{field_indent}  type #{type_const_str}")
+                corrector.replace(node, cleaned_node_source)
+              end
+            end
+          end
+        end
+
+        def on_send(node)
+          field_config_with_inline_type(node) do |type_const|
+            return if ignored_node?(type_const)
+            type_const_str = get_type_argument_str(node, type_const)
+            if ignore_inline_type_str?(type_const_str)
+              # Do nothing -- not loading from another file
+            else
+              add_offense(type_const) do |corrector|
+                cleaned_node_source = delete_type_argument(node, type_const)
+                field_indent = determine_field_indent(node)
+                cleaned_node_source += " do\n#{field_indent}  type #{type_const_str}\n#{field_indent}end"
+                corrector.replace(node, cleaned_node_source)
+              end
+            end
+          end
+        end
+
+
+        private
+
+        def ignore_inline_type_str?(type_str)
+          BUILT_IN_SCALAR_NAMES.include?(type_str)
+        end
+
+        def get_type_argument_str(send_node, type_const)
+          first_pos = type_const.location.expression.begin_pos
+          end_pos = type_const.location.expression.end_pos
+          node_source = send_node.source_range.source
+          node_first_pos = send_node.location.expression.begin_pos
+
+          relative_first_pos = first_pos - node_first_pos
+          end_removal_pos = end_pos - node_first_pos
+
+          node_source[relative_first_pos...end_removal_pos]
+        end
+
+        def delete_type_argument(send_node, type_const)
+          first_pos = type_const.location.expression.begin_pos
+          end_pos = type_const.location.expression.end_pos
+          node_source = send_node.source_range.source
+          node_first_pos = send_node.location.expression.begin_pos
+
+          relative_first_pos = first_pos - node_first_pos
+          end_removal_pos = end_pos - node_first_pos
+
+          begin_removal_pos = relative_first_pos
+          while node_source[begin_removal_pos] != ","
+            begin_removal_pos -= 1
+            if begin_removal_pos < 1
+              raise "Invariant: somehow backtracked to beginning of node looking for a comma (node source: #{node_source.inspect})"
+            end
+          end
+
+          node_source[0...begin_removal_pos] + node_source[end_removal_pos..-1]
+        end
+
+        def determine_field_indent(send_node)
+          surrounding_node = send_node.parent.parent
+          surrounding_source = surrounding_node.source
+          indent_test_idx = send_node.location.expression.begin_pos - surrounding_node.source_range.begin_pos - 1
+          field_indent = "".dup
+          while surrounding_source[indent_test_idx] == " "
+            field_indent << " "
+            indent_test_idx -= 1
+            if indent_test_idx == 0
+              raise "Invariant: somehow backtracted to beginning of class when looking for field indent (source: #{node_source.inspect})"
+            end
+          end
+          field_indent
+        end
+      end
+    end
+  end
+end