graphql 1.8.0 → 1.12.12

data/lib/graphql/types/string.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Types
+    class String < GraphQL::Schema::Scalar
+      description "Represents textual data as UTF-8 character sequences. This type is most often used by GraphQL to represent free-form human-readable text."
+
+      def self.coerce_result(value, ctx)
+        str = value.to_s
+        if str.encoding == Encoding::UTF_8
+          str
+        elsif str.frozen?
+          str.encode(Encoding::UTF_8)
+        else
+          str.encode!(Encoding::UTF_8)
+        end
+      rescue EncodingError
+        err = GraphQL::StringEncodingError.new(str)
+        ctx.schema.type_error(err, ctx)
+      end
+
+      def self.coerce_input(value, _ctx)
+        value.is_a?(::String) ? value : nil
+      end
+
+      default_scalar true
+    end
+  end
+end

data/lib/graphql/types.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+require "graphql/types/boolean"
+require "graphql/types/big_int"
+require "graphql/types/float"
+require "graphql/types/id"
+require "graphql/types/int"
+require "graphql/types/iso_8601_date"
+require "graphql/types/iso_8601_date_time"
+require "graphql/types/json"
+require "graphql/types/string"
+require "graphql/types/relay"

data/lib/graphql/unauthorized_error.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module GraphQL
+  # When an `authorized?` hook returns false, this error is used to communicate the failure.
+  # It's passed to {Schema.unauthorized_object}.
+  #
+  # Alternatively, custom code in `authorized?` may raise this error. It will be routed the same way.
+  class UnauthorizedError < GraphQL::Error
+    # @return [Object] the application object that failed the authorization check
+    attr_reader :object
+
+    # @return [Class] the GraphQL object type whose `.authorized?` method was called (and returned false)
+    attr_reader :type
+
+    # @return [GraphQL::Query::Context] the context for the current query
+    attr_reader :context
+
+    def initialize(message = nil, object: nil, type: nil, context: nil)
+      if message.nil? && object.nil? && type.nil?
+        raise ArgumentError, "#{self.class.name} requires either a message or keywords"
+      end
+
+      @object = object
+      @type = type
+      @context = context
+      message ||= "An instance of #{object.class} failed #{type.graphql_name}'s authorization check"
+      super(message)
+    end
+  end
+end

data/lib/graphql/unauthorized_field_error.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+module GraphQL
+  class UnauthorizedFieldError < GraphQL::UnauthorizedError
+    # @return [Field] the field that failed the authorization check
+    attr_accessor :field
+
+    def initialize(message = nil, object: nil, type: nil, context: nil, field: nil)
+      if message.nil? && [field, type].any?(&:nil?)
+        raise ArgumentError, "#{self.class.name} requires either a message or keywords"
+      end
+
+      @field = field
+      message ||= begin
+        if object
+          "An instance of #{object.class} failed #{type.name}'s authorization check on field #{field.name}"
+        else
+          "Failed #{type.name}'s authorization check on field #{field.name}"
+        end
+      end
+      super(message, object: object, type: type, context: context)
+    end
+  end
+end

data/lib/graphql/union_type.rb

@@ -1,45 +1,37 @@
 # frozen_string_literal: true
 module GraphQL
-  # A Union is is a collection of object types which may appear in the same place.
-  #
-  # The members of a union are declared with `possible_types`.
-  #
-  # @example A union of object types
-  #   MediaUnion = GraphQL::UnionType.define do
-  #     name "Media"
-  #     description "Media objects which you can enjoy"
-  #     possible_types [AudioType, ImageType, VideoType]
-  #   end
-  #
-  # A union itself has no fields; only its members have fields.
-  # So, when you query, you must use fragment spreads to access fields.
-  #
-  # @example Querying for fields on union members
-  #  {
-  #    searchMedia(name: "Jens Lekman") {
-  #      ... on Audio { name, duration }
-  #      ... on Image { name, height, width }
-  #      ... on Video { name, length, quality }
-  #    }
-  #  }
-  #
+  # @api deprecated
   class UnionType < GraphQL::BaseType
-    accepts_definitions :possible_types, :resolve_type
-    ensure_defined :possible_types, :resolve_type, :resolve_type_proc
+    extend Define::InstanceDefinable::DeprecatedDefine
+
+    # Rubocop was unhappy about the syntax when this was a proc literal
+    class AcceptPossibleTypesDefinition
+      def self.call(target, possible_types, options = {})
+        target.add_possible_types(possible_types, **options)
+      end
+    end
+
+    accepts_definitions :resolve_type, :type_membership_class,
+      possible_types: AcceptPossibleTypesDefinition
+    ensure_defined :possible_types, :resolve_type, :resolve_type_proc, :type_membership_class
 
     attr_accessor :resolve_type_proc
+    attr_reader :type_memberships
+    attr_accessor :type_membership_class
 
     def initialize
       super
-      @dirty_possible_types = []
-      @clean_possible_types = nil
+      @type_membership_class = GraphQL::Schema::TypeMembership
+      @type_memberships = []
+      @cached_possible_types = nil
       @resolve_type_proc = nil
     end
 
     def initialize_copy(other)
       super
-      @clean_possible_types = nil
-      @dirty_possible_types = other.dirty_possible_types.dup
+      @type_membership_class = other.type_membership_class
+      @type_memberships = other.type_memberships.dup
+      @cached_possible_types = nil
     end
 
     def kind
@@ -47,26 +39,55 @@ module GraphQL
     end
 
     # @return [Boolean] True if `child_type_defn` is a member of this {UnionType}
-    def include?(child_type_defn)
-      possible_types.include?(child_type_defn)
-    end
-
-    def possible_types=(new_possible_types)
-      @clean_possible_types = nil
-      @dirty_possible_types = new_possible_types
+    def include?(child_type_defn, ctx = GraphQL::Query::NullContext)
+      possible_types(ctx).include?(child_type_defn)
     end
 
     # @return [Array<GraphQL::ObjectType>] Types which may be found in this union
-    def possible_types
-      @clean_possible_types ||= begin
-        if @dirty_possible_types.respond_to?(:map)
-          @dirty_possible_types.map { |type| GraphQL::BaseType.resolve_related_type(type) }
-        else
-          @dirty_possible_types
-        end
+    def possible_types(ctx = GraphQL::Query::NullContext)
+      if ctx == GraphQL::Query::NullContext
+        # Only cache the default case; if we cached for every `ctx`, it would be a memory leak
+        # (The warden should cache calls to this method, so it's called only once per query,
+        # unless user code calls it directly.)
+        @cached_possible_types ||= possible_types_for_context(ctx)
+      else
+        possible_types_for_context(ctx)
       end
     end
 
+    def possible_types=(types)
+      # This is a re-assignment, so clear the previous values
+      @type_memberships = []
+      @cached_possible_types = nil
+      add_possible_types(types, **{})
+    end
+
+    def add_possible_types(types, **options)
+      @type_memberships ||= []
+      Array(types).each { |t|
+        @type_memberships << self.type_membership_class.new(self, t, **options)
+      }
+      nil
+    end
+
+    # Get a possible type of this {UnionType} 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 is a member of this {UnionType}, (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 {UnionType}
+    # @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 {UnionType}, (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 resolve_type(value, ctx)
       ctx.query.resolve_type(self, value)
     end
@@ -75,8 +96,20 @@ module GraphQL
       @resolve_type_proc = new_resolve_type_proc
     end
 
-    protected
+    def type_memberships=(type_memberships)
+      @type_memberships = type_memberships
+    end
+
+    private
 
-    attr_reader :dirty_possible_types
+    def possible_types_for_context(ctx)
+      visible_types = []
+      @type_memberships.each do |type_membership|
+        if type_membership.visible?(ctx)
+          visible_types << BaseType.resolve_related_type(type_membership.object_type)
+        end
+      end
+      visible_types
+    end
   end
 end

data/lib/graphql/unresolved_type_error.rb

@@ -24,8 +24,8 @@ module GraphQL
       @parent_type = parent_type
       @resolved_type = resolved_type
       @possible_types = possible_types
-      message = "The value from \"#{field.name}\" on \"#{parent_type}\" could not be resolved to \"#{field.type}\". " \
-        "(Received: `#{resolved_type.inspect}`, Expected: [#{possible_types.map(&:inspect).join(", ")}]) " \
+      message = "The value from \"#{field.graphql_name}\" on \"#{parent_type.graphql_name}\" could not be resolved to \"#{field.type.to_type_signature}\". " \
+        "(Received: `#{resolved_type.inspect}`, Expected: [#{possible_types.map(&:graphql_name).join(", ")}]) " \
         "Make sure you have defined a `resolve_type` proc on your schema and that value `#{value.inspect}` " \
         "gets resolved to a valid type. You may need to add your type to `orphan_types` if it implements an " \
         "interface but isn't a return type of any other field."

data/lib/graphql/upgrader/member.rb

@@ -13,12 +13,13 @@ module GraphQL
       # @param input_text [String] Untransformed GraphQL-Ruby code
       # @return [String] The input text, with a transformation applied if necessary
       def apply(input_text)
-        raise NotImplementedError, "Return transformed text here"
+        raise GraphQL::RequiredImplementationMissingError, "Return transformed text here"
       end
 
       # Recursively transform a `.define`-DSL-based type expression into a class-ready expression, for example:
       #
       # - `types[X]` -> `[X, null: true]`
+      # - `types[X.to_non_null_type]` -> `[X]`
       # - `Int` -> `Integer`
       # - `X!` -> `X`
       #
@@ -37,6 +38,9 @@ module GraphQL
           if inner_type.start_with?("!")
             nullable = false
             inner_type = inner_type[1..-1]
+          elsif inner_type.end_with?(".to_non_null_type")
+            nullable = false
+            inner_type = inner_type[0...-17]
           else
             nullable = true
           end
@@ -121,7 +125,7 @@ module GraphQL
       end
 
       def apply(input_text)
-        input_text.sub(@find_pattern, @replace_pattern)
+        input_text.gsub(@find_pattern, @replace_pattern)
       end
     end
 
@@ -143,10 +147,10 @@ module GraphQL
             name = matches[:overridden_name]
             if type_name_without_the_type_part != name
               # If the overridden name is still required, use `graphql_name` for it
-              transformable = transformable.sub(/ name (.*)/, ' graphql_name \1')
+              transformable = transformable.gsub(/ name (.*)/, ' graphql_name \1')
             else
               # Otherwise, remove it altogether
-              transformable = transformable.sub(/\s+name ('|").*('|")/, '')
+              transformable = transformable.gsub(/\s+name ('|").*('|")/, '')
             end
           end
         end
@@ -281,43 +285,57 @@ module GraphQL
       def apply(input_text)
         if input_text =~ @proc_check_pattern
           processor = apply_processor(input_text, NamedProcProcessor.new(@proc_name))
-          proc_body = input_text[processor.proc_body_start..processor.proc_body_end]
-          method_defn_indent = " " * processor.proc_defn_indent
-          method_defn = "def self.#{@proc_name}(#{processor.proc_arg_names.join(", ")})\n#{method_defn_indent}  #{proc_body}\n#{method_defn_indent}end\n"
-          method_defn = trim_lines(method_defn)
-          # replace the proc with the new method
-          input_text[processor.proc_defn_start..processor.proc_defn_end] = method_defn
+          processor.proc_to_method_sections.reverse.each do |proc_to_method_section|
+            proc_body = input_text[proc_to_method_section.proc_body_start..proc_to_method_section.proc_body_end]
+            method_defn_indent = " " * proc_to_method_section.proc_defn_indent
+            method_defn = "def self.#{@proc_name}(#{proc_to_method_section.proc_arg_names.join(", ")})\n#{method_defn_indent}  #{proc_body}\n#{method_defn_indent}end\n"
+            method_defn = trim_lines(method_defn)
+            # replace the proc with the new method
+            input_text[proc_to_method_section.proc_defn_start..proc_to_method_section.proc_defn_end] = method_defn
+          end
         end
         input_text
       end
 
       class NamedProcProcessor < Parser::AST::Processor
-        attr_reader :proc_arg_names, :proc_defn_start, :proc_defn_end, :proc_defn_indent, :proc_body_start, :proc_body_end
+        attr_reader :proc_to_method_sections
         def initialize(proc_name)
           @proc_name_sym = proc_name.to_sym
-          @proc_arg_names = nil
-          # Beginning of the `#{proc_name} -> {...}` call
-          @proc_defn_start = nil
-          # End of the last `end/}`
-          @proc_defn_end = nil
-          # Amount of whitespace to insert to the rewritten body
-          @proc_defn_indent = nil
-          # First statement of the proc
-          @proc_body_start = nil
-          # End of last statement in the proc
-          @proc_body_end = nil
-          # Used for identifying the proper block
-          @inside_proc = false
+          @proc_to_method_sections = []
+        end
+
+        class ProcToMethodSection
+          attr_accessor :proc_arg_names, :proc_defn_start, :proc_defn_end, :proc_defn_indent, :proc_body_start, :proc_body_end, :inside_proc
+
+          def initialize
+            # @proc_name_sym = proc_name.to_sym
+            @proc_arg_names = nil
+            # Beginning of the `#{proc_name} -> {...}` call
+            @proc_defn_start = nil
+            # End of the last `end/}`
+            @proc_defn_end = nil
+            # Amount of whitespace to insert to the rewritten body
+            @proc_defn_indent = nil
+            # First statement of the proc
+            @proc_body_start = nil
+            # End of last statement in the proc
+            @proc_body_end = nil
+            # Used for identifying the proper block
+            @inside_proc = false
+          end
         end
 
         def on_send(node)
           receiver, method_name, _args = *node
           if method_name == @proc_name_sym && receiver.nil?
+            proc_section = ProcToMethodSection.new
             source_exp = node.loc.expression
-            @proc_defn_start = source_exp.begin.begin_pos
-            @proc_defn_end = source_exp.end.end_pos
-            @proc_defn_indent = source_exp.column
-            @inside_proc = true
+            proc_section.proc_defn_start = source_exp.begin.begin_pos
+            proc_section.proc_defn_end = source_exp.end.end_pos
+            proc_section.proc_defn_indent = source_exp.column
+            proc_section.inside_proc = true
+
+            @proc_to_method_sections << proc_section
           end
           res = super(node)
           @inside_proc = false
@@ -327,11 +345,14 @@ module GraphQL
         def on_block(node)
           send_node, args_node, body_node = node.children
           _receiver, method_name, _send_args_node = *send_node
-          if method_name == :lambda && @inside_proc
+          if method_name == :lambda && !@proc_to_method_sections.empty? && @proc_to_method_sections[-1].inside_proc
+            proc_to_method_section = @proc_to_method_sections[-1]
+
             source_exp = body_node.loc.expression
-            @proc_arg_names = args_node.children.map { |arg_node| arg_node.children[0].to_s }
-            @proc_body_start = source_exp.begin.begin_pos
-            @proc_body_end = source_exp.end.end_pos
+            proc_to_method_section.proc_arg_names = args_node.children.map { |arg_node| arg_node.children[0].to_s }
+            proc_to_method_section.proc_body_start = source_exp.begin.begin_pos
+            proc_to_method_section.proc_body_end = source_exp.end.end_pos
+            proc_to_method_section.inside_proc = false
           end
           super(node)
         end
@@ -349,30 +370,34 @@ module GraphQL
         if input_text =~ /GraphQL::Relay::Mutation\.define/
           named_proc_processor = apply_processor(input_text, ProcToClassMethodTransform::NamedProcProcessor.new(@proc_name))
           resolve_proc_processor = apply_processor(input_text, ResolveProcToMethodTransform::ResolveProcProcessor.new)
-          proc_body = input_text[named_proc_processor.proc_body_start..named_proc_processor.proc_body_end]
-          method_defn_indent = " " * named_proc_processor.proc_defn_indent
-
-          obj_arg_name, args_arg_name, ctx_arg_name = resolve_proc_processor.proc_arg_names
-          # This is not good, it will hit false positives
-          # Should use AST to make this substitution
-          if obj_arg_name != "_"
-            proc_body.gsub!(/([^\w:.]|^)#{obj_arg_name}([^\w:]|$)/, '\1@object\2')
-          end
-          if ctx_arg_name != "_"
-            proc_body.gsub!(/([^\w:.]|^)#{ctx_arg_name}([^\w:]|$)/, '\1@context\2')
-          end
 
-          method_defn = "def #{@proc_name}(**#{args_arg_name})\n#{method_defn_indent}  #{proc_body}\n#{method_defn_indent}end\n"
-          method_defn = trim_lines(method_defn)
-          # Update usage of args keys
-          method_defn = method_defn.gsub(/#{args_arg_name}(?<method_begin>\.key\?\(?|\[)["':](?<arg_name>[a-zA-Z0-9_]+)["']?(?<method_end>\]|\))?/) do
-            method_begin = $~[:method_begin]
-            arg_name = underscorize($~[:arg_name])
-            method_end = $~[:method_end]
-            "#{args_arg_name}#{method_begin}:#{arg_name}#{method_end}"
+          named_proc_processor.proc_to_method_sections.zip(resolve_proc_processor.resolve_proc_sections).reverse.each do |pair|
+            proc_to_method_section, resolve_proc_section = *pair
+            proc_body = input_text[proc_to_method_section.proc_body_start..proc_to_method_section.proc_body_end]
+            method_defn_indent = " " * proc_to_method_section.proc_defn_indent
+
+            obj_arg_name, args_arg_name, ctx_arg_name = resolve_proc_section.proc_arg_names
+            # This is not good, it will hit false positives
+            # Should use AST to make this substitution
+            if obj_arg_name != "_"
+              proc_body.gsub!(/([^\w:.]|^)#{obj_arg_name}([^\w:]|$)/, '\1object\2')
+            end
+            if ctx_arg_name != "_"
+              proc_body.gsub!(/([^\w:.]|^)#{ctx_arg_name}([^\w:]|$)/, '\1context\2')
+            end
+
+            method_defn = "def #{@proc_name}(**#{args_arg_name})\n#{method_defn_indent}  #{proc_body}\n#{method_defn_indent}end\n"
+            method_defn = trim_lines(method_defn)
+            # Update usage of args keys
+            method_defn = method_defn.gsub(/#{args_arg_name}(?<method_begin>\.key\?\(?|\[)["':](?<arg_name>[a-zA-Z0-9_]+)["']?(?<method_end>\]|\))?/) do
+              method_begin = $~[:method_begin]
+              arg_name = underscorize($~[:arg_name])
+              method_end = $~[:method_end]
+              "#{args_arg_name}#{method_begin}:#{arg_name}#{method_end}"
+            end
+            # replace the proc with the new method
+            input_text[proc_to_method_section.proc_defn_start..proc_to_method_section.proc_defn_end] = method_defn
           end
-          # replace the proc with the new method
-          input_text[named_proc_processor.proc_defn_start..named_proc_processor.proc_defn_end] = method_defn
         end
         input_text
       end
@@ -491,8 +516,8 @@ module GraphQL
           # - Get the three argument names (obj, arg, ctx)
           # - Get the proc body
           # - Find and replace:
-          #  - The ctx argument becomes `@context`
-          #  - The obj argument becomes `@object`
+          #  - The ctx argument becomes `context`
+          #  - The obj argument becomes `object`
           # - Args is trickier:
           #   - If it's not used, remove it
           #   - If it's used, abandon ship and make it `**args`
@@ -508,74 +533,86 @@ module GraphQL
           input_text.match(/(?<field_type>input_field|field|connection|argument) :(?<name>[a-zA-Z_0-9_]*)/)
           field_name = $~[:name]
           processor = apply_processor(input_text, ResolveProcProcessor.new)
-          proc_body = input_text[processor.proc_start..processor.proc_end]
-          obj_arg_name, args_arg_name, ctx_arg_name = processor.proc_arg_names
-          # This is not good, it will hit false positives
-          # Should use AST to make this substitution
-          if obj_arg_name != "_"
-            proc_body.gsub!(/([^\w:.]|^)#{obj_arg_name}([^\w:]|$)/, '\1@object\2')
-          end
-          if ctx_arg_name != "_"
-            proc_body.gsub!(/([^\w:.]|^)#{ctx_arg_name}([^\w:]|$)/, '\1@context\2')
-          end
 
-          method_def_indent = " " * (processor.resolve_indent - 2)
-          # Turn the proc body into a method body
-          method_body = reindent_lines(proc_body, from_indent: processor.resolve_indent + 2, to_indent: processor.resolve_indent)
-          # Add `def... end`
-          method_def = if input_text.include?("argument ")
-            # This field has arguments
-            "def #{field_name}(**#{args_arg_name})"
-          else
-            # No field arguments, so, no method arguments
-            "def #{field_name}"
-          end
-          # Wrap the body in def ... end
-          method_body = "\n#{method_def_indent}#{method_def}\n#{method_body}\n#{method_def_indent}end\n"
-          # Update Argument access to be underscore and symbols
-          # Update `args[...]` and `args.key?`
-          method_body = method_body.gsub(/#{args_arg_name}(?<method_begin>\.key\?\(?|\[)["':](?<arg_name>[a-zA-Z0-9_]+)["']?(?<method_end>\]|\))?/) do
-            method_begin = $~[:method_begin]
-            arg_name = underscorize($~[:arg_name])
-            method_end = $~[:method_end]
-            "#{args_arg_name}#{method_begin}:#{arg_name}#{method_end}"
-          end
+          processor.resolve_proc_sections.reverse.each do |resolve_proc_section|
+            proc_body = input_text[resolve_proc_section.proc_start..resolve_proc_section.proc_end]
+            obj_arg_name, args_arg_name, ctx_arg_name = resolve_proc_section.proc_arg_names
+            # This is not good, it will hit false positives
+            # Should use AST to make this substitution
+            if obj_arg_name != "_"
+              proc_body.gsub!(/([^\w:.]|^)#{obj_arg_name}([^\w:]|$)/, '\1object\2')
+            end
+            if ctx_arg_name != "_"
+              proc_body.gsub!(/([^\w:.]|^)#{ctx_arg_name}([^\w:]|$)/, '\1context\2')
+            end
 
-          # Replace the resolve proc with the method
-          input_text[processor.resolve_start..processor.resolve_end] = ""
-          # The replacement above might have left some preceeding whitespace,
-          # so remove it by deleting all whitespace chars before `resolve`:
-          preceeding_whitespace = processor.resolve_start - 1
-          while input_text[preceeding_whitespace] == " " && preceeding_whitespace > 0
-            input_text[preceeding_whitespace] = ""
-            preceeding_whitespace -= 1
+            method_def_indent = " " * (resolve_proc_section.resolve_indent - 2)
+            # Turn the proc body into a method body
+            method_body = reindent_lines(proc_body, from_indent: resolve_proc_section.resolve_indent + 2, to_indent: resolve_proc_section.resolve_indent)
+            # Add `def... end`
+            method_def = if input_text.include?("argument ")
+              # This field has arguments
+              "def #{field_name}(**#{args_arg_name})"
+            else
+              # No field arguments, so, no method arguments
+              "def #{field_name}"
+            end
+            # Wrap the body in def ... end
+            method_body = "\n#{method_def_indent}#{method_def}\n#{method_body}\n#{method_def_indent}end\n"
+            # Update Argument access to be underscore and symbols
+            # Update `args[...]` and `args.key?`
+            method_body = method_body.gsub(/#{args_arg_name}(?<method_begin>\.key\?\(?|\[)["':](?<arg_name>[a-zA-Z0-9_]+)["']?(?<method_end>\]|\))?/) do
+              method_begin = $~[:method_begin]
+              arg_name = underscorize($~[:arg_name])
+              method_end = $~[:method_end]
+              "#{args_arg_name}#{method_begin}:#{arg_name}#{method_end}"
+            end
+
+            # Replace the resolve proc with the method
+            input_text[resolve_proc_section.resolve_start..resolve_proc_section.resolve_end] = ""
+            # The replacement above might have left some preceeding whitespace,
+            # so remove it by deleting all whitespace chars before `resolve`:
+            preceeding_whitespace = resolve_proc_section.resolve_start - 1
+            while input_text[preceeding_whitespace] == " " && preceeding_whitespace > 0
+              input_text[preceeding_whitespace] = ""
+              preceeding_whitespace -= 1
+            end
+            input_text += method_body
+            input_text
           end
-          input_text += method_body
-          input_text
-        else
-          # No resolve proc
-          input_text
         end
+
+        input_text
       end
 
       class ResolveProcProcessor < Parser::AST::Processor
-        attr_reader :proc_start, :proc_end, :proc_arg_names, :resolve_start, :resolve_end, :resolve_indent
+        attr_reader :resolve_proc_sections
         def initialize
-          @proc_arg_names = nil
-          @resolve_start = nil
-          @resolve_end = nil
-          @resolve_indent = nil
-          @proc_start = nil
-          @proc_end = nil
+          @resolve_proc_sections = []
+        end
+
+        class ResolveProcSection
+          attr_accessor :proc_start, :proc_end, :proc_arg_names, :resolve_start, :resolve_end, :resolve_indent
+          def initialize
+            @proc_arg_names = nil
+            @resolve_start = nil
+            @resolve_end = nil
+            @resolve_indent = nil
+            @proc_start = nil
+            @proc_end = nil
+          end
         end
 
         def on_send(node)
           receiver, method_name, _args = *node
           if method_name == :resolve && receiver.nil?
+            resolve_proc_section = ResolveProcSection.new
             source_exp = node.loc.expression
-            @resolve_start = source_exp.begin.begin_pos
-            @resolve_end = source_exp.end.end_pos
-            @resolve_indent = source_exp.column
+            resolve_proc_section.resolve_start = source_exp.begin.begin_pos
+            resolve_proc_section.resolve_end = source_exp.end.end_pos
+            resolve_proc_section.resolve_indent = source_exp.column
+
+            @resolve_proc_sections << resolve_proc_section
           end
           super(node)
         end
@@ -584,11 +621,15 @@ module GraphQL
           send_node, args_node, body_node = node.children
           _receiver, method_name, _send_args_node = *send_node
           # Assume that the first three-argument proc we enter is the resolve
-          if method_name == :lambda && args_node.children.size == 3 && @proc_arg_names.nil?
+          if (
+            method_name == :lambda && args_node.children.size == 3 &&
+            !@resolve_proc_sections.empty? && @resolve_proc_sections[-1].proc_arg_names.nil?
+          )
+            resolve_proc_section = @resolve_proc_sections[-1]
             source_exp = body_node.loc.expression
-            @proc_arg_names = args_node.children.map { |arg_node| arg_node.children[0].to_s }
-            @proc_start = source_exp.begin.begin_pos
-            @proc_end = source_exp.end.end_pos
+            resolve_proc_section.proc_arg_names = args_node.children.map { |arg_node| arg_node.children[0].to_s }
+            resolve_proc_section.proc_start = source_exp.begin.begin_pos
+            resolve_proc_section.proc_end = source_exp.end.end_pos
           end
           super(node)
         end
@@ -647,6 +688,7 @@ module GraphQL
 
             if return_type
               non_nullable = return_type.sub! /(^|[^\[])!/, '\1'
+              non_nullable ||= return_type.sub! /([^\[])\.to_non_null_type([^\]]|$)/, '\1'
               nullable = !non_nullable
               return_type = normalize_type_expression(return_type)
             else
@@ -729,6 +771,7 @@ module GraphQL
 
     class Member
       def initialize(member, skip: SkipOnNullKeyword, type_transforms: DEFAULT_TYPE_TRANSFORMS, field_transforms: DEFAULT_FIELD_TRANSFORMS, clean_up_transforms: DEFAULT_CLEAN_UP_TRANSFORMS)
+        GraphQL::Deprecation.warn "#{self.class} will be removed from GraphQL-Ruby 2.0 (but there's no point in using it after you've transformed your code, anyways)"
         @member = member
         @skip = skip
         @type_transforms = type_transforms