graphql 2.3.7 → 2.4.0

data/lib/graphql/language/printer.rb

@@ -255,14 +255,14 @@ module GraphQL
 
 
       def print_scalar_type_definition(scalar_type, extension: false)
-        extension ? print_string("extend ") : print_description(scalar_type)
+        extension ? print_string("extend ") : print_description_and_comment(scalar_type)
         print_string("scalar ")
         print_string(scalar_type.name)
         print_directives(scalar_type.directives)
       end
 
       def print_object_type_definition(object_type, extension: false)
-        extension ? print_string("extend ") : print_description(object_type)
+        extension ? print_string("extend ") : print_description_and_comment(object_type)
         print_string("type ")
         print_string(object_type.name)
         print_implements(object_type) unless object_type.interfaces.empty?
@@ -294,7 +294,7 @@ module GraphQL
       end
 
       def print_arguments(arguments, indent: "")
-        if arguments.all? { |arg| !arg.description }
+        if arguments.all? { |arg| !arg.description && !arg.comment }
           print_string("(")
           arguments.each_with_index do |arg, i|
             print_input_value_definition(arg)
@@ -306,6 +306,7 @@ module GraphQL
 
         print_string("(\n")
         arguments.each_with_index do |arg, i|
+          print_comment(arg, indent: "  " + indent, first_in_block: i == 0)
           print_description(arg, indent: "  " + indent, first_in_block: i == 0)
           print_string("  ")
           print_string(indent)
@@ -328,7 +329,7 @@ module GraphQL
       end
 
       def print_interface_type_definition(interface_type, extension: false)
-        extension ? print_string("extend ") : print_description(interface_type)
+        extension ? print_string("extend ") : print_description_and_comment(interface_type)
         print_string("interface ")
         print_string(interface_type.name)
         print_implements(interface_type) if interface_type.interfaces.any?
@@ -337,7 +338,7 @@ module GraphQL
       end
 
       def print_union_type_definition(union_type, extension: false)
-        extension ? print_string("extend ") : print_description(union_type)
+        extension ? print_string("extend ") : print_description_and_comment(union_type)
         print_string("union ")
         print_string(union_type.name)
         print_directives(union_type.directives)
@@ -355,7 +356,7 @@ module GraphQL
       end
 
       def print_enum_type_definition(enum_type, extension: false)
-        extension ? print_string("extend ") : print_description(enum_type)
+        extension ? print_string("extend ") : print_description_and_comment(enum_type)
         print_string("enum ")
         print_string(enum_type.name)
         print_directives(enum_type.directives)
@@ -363,6 +364,7 @@ module GraphQL
           print_string(" {\n")
           enum_type.values.each.with_index do |value, i|
             print_description(value, indent: "  ", first_in_block: i == 0)
+            print_comment(value, indent: "  ", first_in_block: i == 0)
             print_enum_value_definition(value)
           end
           print_string("}")
@@ -377,7 +379,7 @@ module GraphQL
       end
 
       def print_input_object_type_definition(input_object_type, extension: false)
-        extension ? print_string("extend ") : print_description(input_object_type)
+        extension ? print_string("extend ") : print_description_and_comment(input_object_type)
         print_string("input ")
         print_string(input_object_type.name)
         print_directives(input_object_type.directives)
@@ -385,6 +387,7 @@ module GraphQL
           print_string(" {\n")
           input_object_type.fields.each.with_index do |field, i|
             print_description(field, indent: "  ", first_in_block: i == 0)
+            print_comment(field, indent: "  ", first_in_block: i == 0)
             print_string("  ")
             print_input_value_definition(field)
             print_string("\n")
@@ -424,6 +427,18 @@ module GraphQL
         print_string(GraphQL::Language::BlockString.print(node.description, indent: indent))
       end
 
+      def print_comment(node, indent: "", first_in_block: true)
+        return unless node.comment
+
+        print_string("\n") if indent != "" && !first_in_block
+        print_string(GraphQL::Language::Comment.print(node.comment, indent: indent))
+      end
+
+      def print_description_and_comment(node)
+        print_description(node)
+        print_comment(node)
+      end
+
       def print_field_definitions(fields)
         return if fields.empty?
 
@@ -431,6 +446,7 @@ module GraphQL
         i = 0
         fields.each do |field|
           print_description(field, indent: "  ", first_in_block: i == 0)
+          print_comment(field, indent: "  ", first_in_block: i == 0)
           print_string("  ")
           print_field_definition(field)
           print_string("\n")

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 require "graphql/language/block_string"
+require "graphql/language/comment"
 require "graphql/language/printer"
 require "graphql/language/sanitized_printer"
 require "graphql/language/document_from_schema_definition"
@@ -9,7 +10,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"
@@ -49,19 +49,19 @@ module GraphQL
       inside_single_quoted_string = false
       new_query_str = nil
       while !scanner.eos?
-        if (match = scanner.scan(/(?:\\"|[^"\n\r]|""")+/m)) && new_query_str
-          new_query_str << match
-        elsif scanner.scan('"')
+        if scanner.skip(/(?:\\"|[^"\n\r]|""")+/m)
+          new_query_str && (new_query_str << scanner.matched)
+        elsif scanner.skip('"')
           new_query_str && (new_query_str << '"')
           inside_single_quoted_string = !inside_single_quoted_string
-        elsif scanner.scan("\n")
+        elsif scanner.skip("\n")
           if inside_single_quoted_string
             new_query_str ||= query_str[0, scanner.pos - 1]
             new_query_str << '\\n'
           else
             new_query_str && (new_query_str << "\n")
           end
-        elsif scanner.scan("\r")
+        elsif scanner.skip("\r")
           if inside_single_quoted_string
             new_query_str ||= query_str[0, scanner.pos - 1]
             new_query_str << '\\r'

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 ||= Schema::Warden::VisibilityProfile.new(@warden)
       end
     end
   end

data/lib/graphql/query.rb

@@ -95,12 +95,27 @@ 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)
+    # @param visibility_profile [Symbol]
+    def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: nil, validate: true, static_validator: nil, visibility_profile: nil, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: schema.max_depth, max_complexity: schema.max_complexity, warden: nil, use_visibility_profile: 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_visibility_profile.nil?
+        use_visibility_profile = warden ? false : schema.use_visibility_profile?
+      end
+
+      @visibility_profile = visibility_profile
+
+      if use_visibility_profile
+        @visibility_profile = @schema.visibility.profile_for(@context, visibility_profile)
+        @warden = Schema::Warden::NullWarden.new(context: @context, schema: @schema)
+      else
+        @visibility_profile = nil
+        @warden = warden
+      end
+
       @subscription_topic = subscription_topic
       @root_value = root_value
       @fragments = nil
@@ -175,9 +190,8 @@ module GraphQL
       @query_string ||= (document ? document.to_query_string : nil)
     end
 
-    def interpreter?
-      true
-    end
+    # @return [Symbol, nil]
+    attr_reader :visibility_profile
 
     attr_accessor :multiplex
 
@@ -195,8 +209,19 @@ module GraphQL
     def lookahead
       @lookahead ||= begin
         ast_node = selected_operation
-        root_type = warden.root_type_for_operation(ast_node.operation_type || "query")
-        GraphQL::Execution::Lookahead.new(query: self, root_type: root_type, ast_nodes: [ast_node])
+        if ast_node.nil?
+          GraphQL::Execution::Lookahead::NULL_LOOKAHEAD
+        else
+          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
     end
 
@@ -328,7 +353,34 @@ module GraphQL
       with_prepared_ast { @warden }
     end
 
-    def_delegators :warden, :get_type, :get_field, :possible_types, :root_type_for_operation
+    def get_type(type_name)
+      types.type(type_name) # rubocop:disable Development/ContextIsPassedCop
+    end
+
+    def get_field(owner, field_name)
+      types.field(owner, field_name) # rubocop:disable Development/ContextIsPassedCop
+    end
+
+    def possible_types(type)
+      types.possible_types(type) # rubocop:disable Development/ContextIsPassedCop
+    end
+
+    def root_type_for_operation(op_type)
+      case op_type
+      when "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
+      else
+        raise ArgumentError, "unexpected root type name: #{op_type.inspect}; expected 'query', 'mutation', or 'subscription'"
+      end
+    end
+
+    def types
+      @visibility_profile || warden.visibility_profile
+    end
 
     # @param abstract_type [GraphQL::UnionType, GraphQL::InterfaceType]
     # @param value [Object] Any runtime value

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

@@ -0,0 +1,144 @@
+# 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)
+          ignore_node(node)
+          field_config_with_inline_type_and_block(node) do |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)
+          return if part_of_ignored_node?(node)
+          field_config_with_inline_type(node) do |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)
+          if BUILT_IN_SCALAR_NAMES.include?(type_str)
+            true
+          elsif (inner_type_str = type_str.sub(/\[([A-Za-z]+)(, null: (true|false))?\]/, '\1')) && BUILT_IN_SCALAR_NAMES.include?(inner_type_str)
+            true
+          else
+            false
+          end
+        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)
+          type_defn_node = send_node
+
+          while (type_defn_node && !(type_defn_node.class_definition? || type_defn_node.module_definition?))
+            type_defn_node = type_defn_node.parent
+          end
+
+          if type_defn_node.nil?
+            raise "Invariant: Something went wrong in GraphQL-Ruby, couldn't find surrounding class definition for field (#{send_node}).\n\nPlease report this error on GitHub."
+          end
+
+          type_defn_source = type_defn_node.source
+          indent_test_idx = send_node.location.expression.begin_pos - type_defn_node.source_range.begin_pos - 1
+          field_indent = "".dup
+          while type_defn_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

data/lib/graphql/rubocop/graphql/root_types_in_block.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+require_relative "./base_cop"
+
+module GraphQL
+  module Rubocop
+    module GraphQL
+      # Identify (and auto-correct) any root types in your schema file.
+      #
+      # @example
+      #   # bad, immediately causes Rails to load `app/graphql/types/query.rb`
+      #   query Types::Query
+      #
+      #   # good, defers loading until the file is needed
+      #   query { Types::Query }
+      #
+      class RootTypesInBlock < BaseCop
+        MSG = "type configuration can be moved to a block to defer loading the type's file"
+
+        def_node_matcher :root_type_config_without_block, <<-Pattern
+        (
+          send nil? {:query :mutation :subscription} const
+        )
+        Pattern
+
+        def on_send(node)
+          root_type_config_without_block(node) do
+            add_offense(node) do |corrector|
+              new_node_source = node.source_range.source
+              new_node_source.sub!(/(query|mutation|subscription)/, '\1 {')
+              new_node_source << " }"
+              corrector.replace(node, new_node_source)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/rubocop.rb

@@ -2,3 +2,5 @@
 
 require "graphql/rubocop/graphql/default_null_true"
 require "graphql/rubocop/graphql/default_required_true"
+require "graphql/rubocop/graphql/field_type_in_block"
+require "graphql/rubocop/graphql/root_types_in_block"

data/lib/graphql/schema/addition.rb

@@ -189,6 +189,7 @@ module GraphQL
           add_directives_from(type)
           if type.kind.fields?
             type.all_field_definitions.each do |field|
+              field.ensure_loaded
               name = field.graphql_name
               field_type = field.type.unwrap
               if !field_type.is_a?(GraphQL::Schema::LateBoundType)

data/lib/graphql/schema/always_visible.rb

@@ -1,9 +1,13 @@
 # frozen_string_literal: true
 module GraphQL
   class Schema
-    class AlwaysVisible
+    module AlwaysVisible
       def self.use(schema, **opts)
-        schema.warden_class = GraphQL::Schema::Warden::NullWarden
+        schema.extend(self)
+      end
+
+      def visible?(_member, _context)
+        true
       end
     end
   end

data/lib/graphql/schema/argument.rb

@@ -50,11 +50,12 @@ module GraphQL
       # @param deprecation_reason [String]
       # @param validates [Hash, nil] Options for building validators, if any should be applied
       # @param replace_null_with_default [Boolean] if `true`, incoming values of `null` will be replaced with the configured `default_value`
-      def initialize(arg_name = nil, type_expr = nil, desc = nil, required: true, type: nil, name: nil, loads: nil, description: nil, ast_node: nil, default_value: NOT_CONFIGURED, as: nil, from_resolver: false, camelize: true, prepare: nil, owner:, validates: nil, directives: nil, deprecation_reason: nil, replace_null_with_default: false, &definition_block)
+      def initialize(arg_name = nil, type_expr = nil, desc = nil, required: true, type: nil, name: nil, loads: nil, description: nil, comment: nil, ast_node: nil, default_value: NOT_CONFIGURED, as: nil, from_resolver: false, camelize: true, prepare: nil, owner:, validates: nil, directives: nil, deprecation_reason: nil, replace_null_with_default: false, &definition_block)
         arg_name ||= name
         @name = -(camelize ? Member::BuildType.camelize(arg_name.to_s) : arg_name.to_s)
         @type_expr = type_expr || type
         @description = desc || description
+        @comment = comment
         @null = required != true
         @default_value = default_value
         if replace_null_with_default
@@ -129,6 +130,17 @@ module GraphQL
         end
       end
 
+      attr_writer :comment
+
+      # @return [String] Comment for this argument
+      def comment(text = nil)
+        if text
+          @comment = text
+        else
+          @comment
+        end
+      end
+
       # @return [String] Deprecation reason for this argument
       def deprecation_reason(text = nil)
         if text
@@ -352,6 +364,7 @@ module GraphQL
 
       # @api private
       def validate_default_value
+        return unless default_value?
         coerced_default_value = begin
           # This is weird, but we should accept single-item default values for list-type arguments.
           # If we used `coerce_isolated_input` below, it would do this for us, but it's not really

data/lib/graphql/schema/build_from_definition.rb

@@ -127,11 +127,12 @@ module GraphQL
           builder = self
 
           found_types = types.values
+          object_types = found_types.select { |t| t.respond_to?(:kind) && t.kind.object? }
           schema_class = Class.new(schema_superclass) do
             begin
               # Add these first so that there's some chance of resolving late-bound types
               add_type_and_traverse(found_types, root: false)
-              orphan_types(found_types.select { |t| t.respond_to?(:kind) && t.kind.object? })
+              orphan_types(object_types)
               query query_root_type
               mutation mutation_root_type
               subscription subscription_root_type
@@ -141,6 +142,12 @@ module GraphQL
               raise InvalidDocumentError, "Type \"#{type_name}\" not found in document.", err_backtrace
             end
 
+            object_types.each do |t|
+              t.interfaces.each do |int_t|
+                int_t.orphan_types(t)
+              end
+            end
+
             if default_resolve.respond_to?(:resolve_type)
               def self.resolve_type(*args)
                 self.definition_default_resolve.resolve_type(*args)
@@ -181,6 +188,7 @@ module GraphQL
 
             def self.inherited(child_class)
               child_class.definition_default_resolve = self.definition_default_resolve
+              super
             end
           end
 

data/lib/graphql/schema/directive/flagged.rb

@@ -7,7 +7,7 @@ module GraphQL
       # In this case, the server hides types and fields _entirely_, unless the current context has certain `:flags` present.
       class Flagged < GraphQL::Schema::Directive
         def initialize(target, **options)
-          if target.is_a?(Module) && !target.ancestors.include?(VisibleByFlag)
+          if target.is_a?(Module)
             # This is type class of some kind, `include` will put this module
             # in between the type class itself and its super class, so `super` will work fine
             target.include(VisibleByFlag)