graphql 2.0.31 → 2.6.1

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/runtime_error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+module GraphQL
+  class RuntimeError < Error
+    include GraphQL::Execution::Finalizer
+  end
+end

data/lib/graphql/schema/addition.rb

@@ -12,7 +12,7 @@ module GraphQL
         @possible_types = {}
         @types = {}
         @union_memberships = {}
-        @references = Hash.new { |h, k| h[k] = [] }
+        @references = Hash.new { |h, k| h[k] = Set.new }
         @arguments_with_default_values = []
         add_type_and_traverse(new_types)
       end
@@ -20,7 +20,7 @@ module GraphQL
       private
 
       def references_to(thing, from:)
-        @references[thing] << from
+        @references[thing].add(from)
       end
 
       def get_type(name)
@@ -40,7 +40,7 @@ module GraphQL
       end
 
       def add_directives_from(owner)
-        if (dir_instances = owner.directives).any?
+        if !(dir_instances = owner.directives).empty?
           dirs = dir_instances.map(&:class)
           @directives.merge(dirs)
           add_type_and_traverse(dirs)
@@ -95,7 +95,7 @@ module GraphQL
             # It's a union with possible_types
             # Replace the item by class name
             owner.assign_type_membership_object_type(type)
-            @possible_types[owner.graphql_name] = owner.possible_types
+            @possible_types[owner] = owner.possible_types
           elsif type.kind.interface? && (owner.kind.object? || owner.kind.interface?)
             new_interfaces = []
             owner.interfaces.each do |int_t|
@@ -110,7 +110,7 @@ module GraphQL
             end
             owner.implements(*new_interfaces)
             new_interfaces.each do |int|
-              pt = @possible_types[int.graphql_name] ||= []
+              pt = @possible_types[int] ||= []
               if !pt.include?(owner) && owner.is_a?(Class)
                 pt << owner
               end
@@ -126,6 +126,7 @@ module GraphQL
           @types[type.graphql_name] = type
         when GraphQL::Schema::Field, GraphQL::Schema::Argument
           orig_type = owner.type
+          unwrapped_t = type
           # Apply list/non-null wrapper as needed
           if orig_type.respond_to?(:of_type)
             transforms = []
@@ -142,6 +143,7 @@ module GraphQL
             transforms.reverse_each { |t| type = type.public_send(t) }
           end
           owner.type = type
+          references_to(unwrapped_t, from: owner)
         else
           raise "Unexpected update: #{owner.inspect} #{type.inspect}"
         end
@@ -164,7 +166,9 @@ module GraphQL
           @directives << type
           type.all_argument_definitions.each do |arg|
             arg_type = arg.type.unwrap
-            references_to(arg_type, from: arg)
+            if !arg_type.is_a?(GraphQL::Schema::LateBoundType)
+              references_to(arg_type, from: arg)
+            end
             path.push(arg.graphql_name)
             add_type(arg_type, owner: arg, late_types: late_types, path: path)
             path.pop
@@ -185,16 +189,21 @@ 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
-              references_to(field_type, from: field)
+              if !field_type.is_a?(GraphQL::Schema::LateBoundType)
+                references_to(field_type, from: field)
+              end
               path.push(name)
               add_type(field_type, owner: field, late_types: late_types, path: path)
               add_directives_from(field)
               field.all_argument_definitions.each do |arg|
                 add_directives_from(arg)
                 arg_type = arg.type.unwrap
-                references_to(arg_type, from: arg)
+                if !arg_type.is_a?(GraphQL::Schema::LateBoundType)
+                  references_to(arg_type, from: arg)
+                end
                 path.push(arg.graphql_name)
                 add_type(arg_type, owner: arg, late_types: late_types, path: path)
                 path.pop
@@ -209,7 +218,9 @@ module GraphQL
             type.all_argument_definitions.each do |arg|
               add_directives_from(arg)
               arg_type = arg.type.unwrap
-              references_to(arg_type, from: arg)
+              if !arg_type.is_a?(GraphQL::Schema::LateBoundType)
+                references_to(arg_type, from: arg)
+              end
               path.push(arg.graphql_name)
               add_type(arg_type, owner: arg, late_types: late_types, path: path)
               path.pop
@@ -219,7 +230,7 @@ module GraphQL
             end
           end
           if type.kind.union?
-            @possible_types[type.graphql_name] = type.all_possible_types
+            @possible_types[type] = type.all_possible_types
             path.push("possible_types")
             type.all_possible_types.each do |t|
               add_type(t, owner: type, late_types: late_types, path: path)
@@ -234,7 +245,7 @@ module GraphQL
             path.pop
           end
           if type.kind.object?
-            possible_types_for_this_name = @possible_types[type.graphql_name] ||= []
+            possible_types_for_this_name = @possible_types[type] ||= []
             possible_types_for_this_name << type
           end
 
@@ -246,8 +257,10 @@ module GraphQL
                 interface_type = interface_type_membership.abstract_type
                 # We can get these now; we'll have to get late-bound types later
                 if interface_type.is_a?(Module) && type.is_a?(Class)
-                  implementers = @possible_types[interface_type.graphql_name] ||= []
-                  implementers << type
+                  implementers = @possible_types[interface_type] ||= []
+                  if !implementers.include?(type)
+                    implementers << type
+                  end
                 end
               when String, Schema::LateBoundType
                 interface_type = interface_type_membership

data/lib/graphql/schema/always_visible.rb

@@ -1,9 +1,14 @@
 # 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.use(GraphQL::Schema::Visibility, profiles: { nil => {} })
+        schema.extend(self)
+      end
+
+      def visible?(_member, _context)
+        true
       end
     end
   end

data/lib/graphql/schema/argument.rb

@@ -4,6 +4,7 @@ module GraphQL
     class Argument
       include GraphQL::Schema::Member::HasPath
       include GraphQL::Schema::Member::HasAstNode
+      include GraphQL::Schema::Member::HasAuthorization
       include GraphQL::Schema::Member::HasDirectives
       include GraphQL::Schema::Member::HasDeprecationReason
       include GraphQL::Schema::Member::HasValidators
@@ -39,9 +40,14 @@ module GraphQL
       # @param arg_name [Symbol]
       # @param type_expr
       # @param desc [String]
+      # @param type [Class, Array<Class>] Input type; positional argument also accepted
+      # @param name [Symbol] positional argument also accepted        # @param loads [Class, Array<Class>] A GraphQL type to load for the given ID when one is present
+      # @param definition_block [Proc] Called with the newly-created {Argument}
+      # @param owner [Class] Private, used by GraphQL-Ruby during schema definition
       # @param required [Boolean, :nullable] if true, this argument is non-null; if false, this argument is nullable. If `:nullable`, then the argument must be provided, though it may be `null`.
       # @param description [String]
       # @param default_value [Object]
+      # @param loads [Class, Array<Class>] A GraphQL type to load for the given ID when one is present
       # @param as [Symbol] Override the keyword name when passed to a method
       # @param prepare [Symbol] A method to call to transform this argument's valuebefore sending it to field resolution
       # @param camelize [Boolean] if true, the name will be camelized when building the schema
@@ -50,11 +56,15 @@ 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)
+      # @param comment [String] Private, used by GraphQL-Ruby when parsing GraphQL schema files
+      # @param ast_node [GraphQL::Language::Nodes::InputValueDefinition] Private, used by GraphQL-Ruby when parsing schema files
+      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)
+        NameValidator.validate!(@name)
         @type_expr = type_expr || type
         @description = desc || description
+        @comment = comment
         @null = required != true
         @default_value = default_value
         if replace_null_with_default
@@ -88,11 +98,8 @@ module GraphQL
         end
 
         if definition_block
-          if definition_block.arity == 1
-            instance_exec(self, &definition_block)
-          else
-            instance_eval(&definition_block)
-          end
+          # `self` will still be self, it will also be the first argument to the block:
+          instance_exec(self, &definition_block)
         end
       end
 
@@ -129,6 +136,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
@@ -147,6 +165,10 @@ module GraphQL
         true
       end
 
+      def authorizes?(_context)
+        self.method(:authorized?).owner != GraphQL::Schema::Argument
+      end
+
       def authorized?(obj, value, ctx)
         authorized_as_type?(obj, value, ctx, as_type: type)
       end
@@ -202,12 +224,17 @@ module GraphQL
         @statically_coercible = !requires_parent_object
       end
 
+      def freeze
+        statically_coercible?
+        super
+      end
+
       # Apply the {prepare} configuration to `value`, using methods from `obj`.
       # Used by the runtime.
       # @api private
       def prepare_value(obj, value, context: nil)
-        if value.is_a?(GraphQL::Schema::InputObject)
-          value = value.prepare
+        if type.unwrap.kind.input_object?
+          value = recursively_prepare_input_object(value, type, context)
         end
 
         Schema::Validator.validate!(validators, obj, context, value)
@@ -221,8 +248,13 @@ module GraphQL
             #
             # This will have to be called later, when the runtime object _is_ available.
             value
-          else
+          elsif obj.respond_to?(@prepare)
             obj.public_send(@prepare, value)
+          elsif owner.respond_to?(@prepare)
+            owner.public_send(@prepare, value, context || obj.context)
+          else
+            raise "Invalid prepare for #{@owner.name}.name: #{@prepare.inspect}. "\
+              "Could not find prepare method #{@prepare} on #{obj.class} or #{owner}."
           end
         elsif @prepare.respond_to?(:call)
           @prepare.call(value, context || obj.context)
@@ -285,6 +317,7 @@ module GraphQL
             # TODO code smell to access such a deeply-nested constant in a distant module
             argument_values[arg_key] = GraphQL::Execution::Interpreter::ArgumentValue.new(
               value: resolved_loaded_value,
+              original_value: resolved_coerced_value,
               definition: self,
               default_used: default_used,
             )
@@ -306,10 +339,15 @@ module GraphQL
           context.query.after_lazy(custom_loaded_value) do |custom_value|
             if loads
               if type.list?
-                loaded_values = custom_value.each_with_index.map { |custom_val, idx|
-                  id = coerced_value[idx]
-                  load_method_owner.authorize_application_object(self, id, context, custom_val)
-                }
+                loaded_values = []
+                context.dataloader.run_isolated do
+                  custom_value.each_with_index.map { |custom_val, idx|
+                    id = coerced_value[idx]
+                    context.dataloader.append_job do
+                      loaded_values[idx] = load_method_owner.authorize_application_object(self, id, context, custom_val)
+                    end
+                  }
+                end
                 context.schema.after_any_lazies(loaded_values, &:itself)
               else
                 load_method_owner.authorize_application_object(self, coerced_value, context, custom_loaded_value)
@@ -320,7 +358,16 @@ module GraphQL
           end
         elsif loads
           if type.list?
-            loaded_values = coerced_value.map { |val| load_method_owner.load_and_authorize_application_object(self, val, context) }
+            loaded_values = []
+            # We want to run these list items all together,
+            # but we also need to wait for the result so we can return it :S
+            context.dataloader.run_isolated do
+              coerced_value.each_with_index { |val, idx|
+                context.dataloader.append_job do
+                  loaded_values[idx] = load_method_owner.load_and_authorize_application_object(self, val, context)
+                end
+              }
+            end
             context.schema.after_any_lazies(loaded_values, &:itself)
           else
             load_method_owner.load_and_authorize_application_object(self, coerced_value, context)
@@ -332,6 +379,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
@@ -367,6 +415,22 @@ module GraphQL
 
       private
 
+      def recursively_prepare_input_object(value, type, context)
+        if type.non_null?
+          type = type.of_type
+        end
+
+        if type.list? && !value.nil?
+          inner_type = type.of_type
+          value.map { |v| recursively_prepare_input_object(v, inner_type, context) }
+        elsif value.is_a?(GraphQL::Schema::InputObject)
+          value.validate_for(context)
+          value.prepare
+        else
+          value
+        end
+      end
+
       def validate_input_type(input_type)
         if input_type.is_a?(String) || input_type.is_a?(GraphQL::Schema::LateBoundType)
           # Do nothing; assume this will be validated later

data/lib/graphql/schema/base_64_encoder.rb

@@ -1,18 +1,16 @@
 # frozen_string_literal: true
-
-require 'graphql/schema/base_64_bp'
-
+require "base64"
 module GraphQL
   class Schema
     # @api private
     module Base64Encoder
       def self.encode(unencoded_text, nonce: false)
-        Base64Bp.urlsafe_encode64(unencoded_text, padding: false)
+        Base64.urlsafe_encode64(unencoded_text, padding: false)
       end
 
       def self.decode(encoded_text, nonce: false)
         # urlsafe_decode64 is for forward compatibility
-        Base64Bp.urlsafe_decode64(encoded_text)
+        Base64.urlsafe_decode64(encoded_text)
       rescue ArgumentError
         raise GraphQL::ExecutionError, "Invalid input: #{encoded_text.inspect}"
       end