graphql 1.8.0.pre9 → 1.8.0.pre10

data/lib/graphql/schema/relay_classic_mutation.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    # Mutations that extend this base class get some conventions added for free:
+    #
+    # - An argument called `clientMutationId` is _always_ added, but it's not passed
+    #   to the resolve method. The value is re-inserted to the response. (It's for
+    #   client libraries to manage optimistic updates.)
+    # - The returned object type always has a field called `clientMutationId` to support that.
+    # - The mutation accepts one argument called `input`, `argument`s defined in the mutation
+    #   class are added to that input object, which is generated by the mutation.
+    #
+    # These conventions were first specified by Relay Classic, but they come in handy:
+    #
+    # - `clientMutationId` supports optimistic updates and cache rollbacks on the client
+    # - using a single `input:` argument makes it easy to post whole JSON objects to the mutation
+    #   using one GraphQL variable (`$input`) instead of making a separate variable for each argument.
+    #
+    # @see {GraphQL::Schema::Mutation} for an example, it's basically the same.
+    #
+    class RelayClassicMutation < GraphQL::Schema::Mutation
+      # The payload should always include this field
+      field(:client_mutation_id, String, "A unique identifier for the client performing the mutation.", null: true)
+
+      class << self
+        # The base class for generated input object types
+        # @param new_class [Class] The base class to use for generating input object definitions
+        # @return [Class] The base class for this mutation's generated input object (default is {GraphQL::Schema::InputObject})
+        def input_object_class(new_class = nil)
+          if new_class
+            @input_object_class = new_class
+          end
+          @input_object_class || (superclass.respond_to?(:input_object_class) ? superclass.input_object_class : GraphQL::Schema::InputObject)
+        end
+
+        # @param new_input_type [Class, nil] If provided, it configures this mutation to accept `new_input_type` instead of generating an input type
+        # @return [Class] The generated {Schema::InputObject} class for this mutation's `input`
+        def input_type(new_input_type = nil)
+          if new_input_type
+            @input_type = new_input_type
+          end
+          @input_type ||= generate_input_type
+        end
+
+        private
+
+        # Extend {Schema::Mutation.generate_field} to add the `input` argument
+        def generate_field
+          field_instance = super
+          field_instance.own_arguments.clear
+          field_instance.argument(:input, input_type, required: true)
+          field_instance
+        end
+
+        # Generate the input type for the `input:` argument
+        # To customize how input objects are generated, override this method
+        # @return [Class] a subclass of {.input_object_class}
+        def generate_input_type
+          mutation_args = arguments
+          mutation_name = graphql_name
+          mutation_class = self
+          Class.new(input_object_class) do
+            graphql_name("#{mutation_name}Input")
+            description("Autogenerated input type of #{mutation_name}")
+            mutation(mutation_class)
+            own_arguments.merge!(mutation_args)
+            argument :client_mutation_id, String, "A unique identifier for the client performing the mutation.", required: false
+          end
+        end
+
+        # Override {GraphQL::Schema::Mutation.resolve_field} to
+        # delete `client_mutation_id` from the kwargs.
+        def resolve_field(obj, args, ctx)
+          mutation = self.new(object: obj, arguments: args, context: ctx.query.context)
+          kwargs = args.to_kwargs
+          # This is handled by Relay::Mutation::Resolve, a bit hacky, but here we are.
+          kwargs.delete(:client_mutation_id)
+          extras.each { |e| kwargs[e] = ctx.public_send(e) }
+          mutation.resolve(**kwargs)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/scalar.rb

@@ -19,6 +19,7 @@ module GraphQL
           type_defn.description = description
           type_defn.coerce_result = method(:coerce_result)
           type_defn.coerce_input = method(:coerce_input)
+          type_defn.metadata[:type_class] = self
           type_defn
         end
       end

data/lib/graphql/schema/traversal.rb

@@ -158,7 +158,7 @@ Some late-bound types couldn't be resolved:
             end
           elsif !prev_type.equal?(type_defn)
             # If the previous entry in the map isn't the same object we just found, raise.
-            raise("Duplicate type definition found for name '#{type_defn.name}' (#{prev_type.metadata[:object_class]}, #{type_defn.metadata[:object_class]}})")
+            raise("Duplicate type definition found for name '#{type_defn.name}' (#{prev_type.metadata[:type_class]}, #{type_defn.metadata[:type_class]}})")
           end
         when Class
           if member.respond_to?(:graphql_definition)

data/lib/graphql/schema/union.rb

@@ -23,6 +23,7 @@ module GraphQL
           if respond_to?(:resolve_type)
             type_defn.resolve_type = method(:resolve_type)
           end
+          type_defn.metadata[:type_class] = self
           type_defn
         end
       end

data/lib/graphql/subscriptions/action_cable_subscriptions.rb

@@ -39,7 +39,7 @@ module GraphQL
     #       })
     #
     #       payload = {
-    #         result: result.subscription? ? nil : result.to_h,
+    #         result: result.subscription? ? {data: nil} : result.to_h,
     #         more: result.subscription?,
     #       }
     #

data/lib/graphql/unresolved_type_error.rb

@@ -26,8 +26,9 @@ module GraphQL
       @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(", ")}]) " \
-        "Make sure you have defined a `type_from_object` proc on your schema and that value `#{value.inspect}` " \
-        "gets resolved to a valid type."
+        "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."
       super(message)
     end
   end

data/lib/graphql/upgrader/member.rb

@@ -107,6 +107,19 @@ module GraphQL
       end
     end
 
+    # Turns `{X} = GraphQL::Relay::Mutation.define do` into `class {X} < Mutations::BaseMutation`
+    class MutationDefineToClassTransform < Transform
+      # @param base_class_name [String] Replacement pattern for the base class name. Use this if your Mutation base class has a nonstandard name.
+      def initialize(base_class_name: "Mutations::BaseMutation")
+        @find_pattern = /([a-zA-Z_0-9:]*) = GraphQL::Relay::Mutation.define do/
+        @replace_pattern = "class \\1 < #{base_class_name}"
+      end
+
+      def apply(input_text)
+        input_text.sub(@find_pattern, @replace_pattern)
+      end
+    end
+
     # Remove `name "Something"` if it is redundant with the class name.
     # Or, if it is not redundant, move it to `graphql_name "Something"`.
     class NameTransform < Transform
@@ -138,7 +151,7 @@ module GraphQL
         keep_looking = true
         while keep_looking do
           keep_looking = false
-          input_text = input_text.gsub(/(?<field>(?:field|connection|argument).*?,)\n(\s*)(?<next_line>.*)/) do
+          input_text = input_text.gsub(/(?<field>(?:field|input_field|return_field|connection|argument)(?:\(.*|.*,))\n\s*(?<next_line>.+)/) do
             keep_looking = true
             field = $~[:field].chomp
             next_line = $~[:next_line]
@@ -150,11 +163,21 @@ module GraphQL
       end
     end
 
+    # Remove parens from method call - normalize for processing
+    class RemoveMethodParensTransform < Transform
+      def apply(input_text)
+        input_text.sub(
+          /(field|input_field|return_field|connection|argument)\( *(.*?) *\) */,
+          '\1 \2'
+        )
+      end
+    end
+
     # Move `type X` to be the second positional argument to `field ...`
     class PositionalTypeArgTransform < Transform
       def apply(input_text)
         input_text.gsub(
-          /(?<field>(?:field|connection|argument) :(?:[a-zA-Z_0-9]*)) do(?<block_contents>.*?)[ ]*type (?<return_type>.*?)\n/m
+          /(?<field>(?:field|input_field|return_field|connection|argument) :(?:[a-zA-Z_0-9]*)) do(?<block_contents>.*?)[ ]*type (?<return_type>.*?)\n/m
         ) do
           field = $~[:field]
           block_contents = $~[:block_contents]
@@ -183,7 +206,7 @@ module GraphQL
 
       def apply(input_text)
         input_text.gsub(
-          /(?<field>(?:field|connection|argument).*) do(?<block_contents>.*?)[ ]*#{@kwarg} (?<kwarg_value>.*?)\n/m
+          /(?<field>(?:field|return_field|input_field|connection|argument).*) do(?<block_contents>.*?)[ ]*#{@kwarg} (?<kwarg_value>.*?)\n/m
         ) do
           field = $~[:field]
           block_contents = $~[:block_contents]
@@ -207,7 +230,7 @@ module GraphQL
     class RemoveRedundantKwargTransform < Transform
       def initialize(kwarg:)
         @kwarg = kwarg
-        @finder_pattern = /(field|connection|argument) :(?<name>[a-zA-Z_0-9]*).*#{@kwarg}: ['":](?<kwarg_value>[a-zA-Z_0-9?!]+)['"]?/
+        @finder_pattern = /(field|return_field|input_field|connection|argument) :(?<name>[a-zA-Z_0-9]*).*#{@kwarg}: ['":](?<kwarg_value>[a-zA-Z_0-9?!]+)['"]?/
       end
 
       def apply(input_text)
@@ -227,7 +250,7 @@ module GraphQL
     # (They'll be automatically camelized later.)
     class UnderscoreizeFieldNameTransform < Transform
       def apply(input_text)
-        input_text.gsub /(?<field_type>input_field|field|connection|argument) :(?<name>[a-zA-Z_0-9_]*)/ do
+        input_text.gsub /(?<field_type>input_field|return_field|field|connection|argument) :(?<name>[a-zA-Z_0-9_]*)/ do
           field_type = $~[:field_type]
           camelized_name = $~[:name]
           underscored_name = underscorize(camelized_name)
@@ -304,6 +327,151 @@ module GraphQL
       end
     end
 
+    class MutationResolveProcToMethodTransform < Transform
+      # @param proc_name [String] The name of the proc to be moved to `def self.#{proc_name}`
+      def initialize(proc_name: "resolve")
+        @proc_name = proc_name
+      end
+
+      # TODO dedup with ResolveProcToMethodTransform
+      def apply(input_text)
+        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}"
+          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
+    end
+
+    # Find hash literals which are returned from mutation resolves,
+    # and convert their keys to underscores. This catches a lot of cases but misses
+    # hashes which are initialized anywhere except in the return expression.
+    class UnderscorizeMutationHashTransform < Transform
+      def apply(input_text)
+        if input_text =~ /def resolve\(\*\*/
+          processor = apply_processor(input_text, ReturnedHashLiteralProcessor.new)
+          # Use reverse_each to avoid messing up positions
+          processor.keys_to_upgrade.reverse_each do |key_data|
+            underscored_key = underscorize(key_data[:key].to_s)
+            if key_data[:operator] == ":"
+              input_text[key_data[:start]...key_data[:end]] = underscored_key
+            else
+              input_text[key_data[:start]...key_data[:end]] = ":#{underscored_key}"
+            end
+          end
+        end
+        input_text
+      end
+
+      class ReturnedHashLiteralProcessor < Parser::AST::Processor
+        attr_reader :keys_to_upgrade
+        def initialize
+          @keys_to_upgrade = []
+        end
+
+        def on_def(node)
+          method_name, _args, body = *node
+          if method_name == :resolve
+            possible_returned_hashes = find_returned_hashes(body, returning: false)
+            possible_returned_hashes.each do |hash_node|
+              pairs = *hash_node
+              pairs.each do |pair_node|
+                if pair_node.type == :pair # Skip over :kwsplat
+                  pair_k, _pair_v = *pair_node
+                  if pair_k.type == :sym && pair_k.children[0].to_s =~ /[a-z][A-Z]/ # Does it have any camelcase boundaries?
+                    source_exp = pair_k.loc.expression
+                    @keys_to_upgrade << {
+                      start: source_exp.begin.begin_pos,
+                      end: source_exp.end.end_pos,
+                      key: pair_k.children[0],
+                      operator: pair_node.loc.operator.source,
+                    }
+                  end
+                end
+              end
+            end
+          end
+
+        end
+
+        private
+
+        # Look for hash nodes, starting from `node`.
+        # Return hash nodes that are valid candiates for returning from this method.
+        def find_returned_hashes(node, returning:)
+          if node.is_a?(Array)
+            *possible_returns, last_expression = *node
+            return possible_returns.map { |c| find_returned_hashes(c, returning: false) }.flatten +
+              # Check the last expression of a method body
+              find_returned_hashes(last_expression, returning: returning)
+          end
+
+          case node.type
+          when :hash
+            if returning
+              [node]
+            else
+              # This is some random hash literal
+              []
+            end
+          when :begin
+            # Check the last expression of a method body
+            find_returned_hashes(node.children, returning: true)
+          when :resbody
+            _condition, _assign, body = *node
+            find_returned_hashes(body, returning: returning)
+          when :kwbegin
+            find_returned_hashes(node.children, returning: returning)
+          when :rescue
+            try_body, rescue_body, _ensure_body = *node
+            find_returned_hashes(try_body, returning: returning) + find_returned_hashes(rescue_body, returning: returning)
+          when :block
+            # Check methods with blocks for possible returns
+            method_call, _args, *body = *node
+            if method_call.type == :send
+              find_returned_hashes(body, returning: returning)
+            end
+          when :if
+            # Check each branch of a conditional
+            _condition, *branches = *node
+            branches.compact.map { |b| find_returned_hashes(b, returning: returning) }.flatten
+          when :return
+            find_returned_hashes(node.children.first, returning: true)
+          else
+            []
+          end
+        rescue
+          p "--- UnderscorizeMutationHashTransform crashed on node: ---"
+          p node
+          raise
+        end
+
+      end
+    end
 
     class ResolveProcToMethodTransform < Transform
       def apply(input_text)
@@ -334,10 +502,10 @@ module GraphQL
           # 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')
+            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')
+            proc_body.gsub!(/([^\w:.]|^)#{ctx_arg_name}([^\w:]|$)/, '\1@context\2')
           end
 
           method_def_indent = " " * (processor.resolve_indent - 2)
@@ -452,8 +620,8 @@ module GraphQL
 
     class UpdateMethodSignatureTransform < Transform
       def apply(input_text)
-        input_text.scan(/(?:input_field|field|connection|argument) .*$/).each do |field|
-          matches = /(?<field_type>input_field|field|connection|argument) :(?<name>[a-zA-Z_0-9_]*)?(:?, +(?<return_type>([A-Za-z\[\]\.\!_0-9\(\)]|::|-> ?\{ ?| ?\})+))?(?<remainder>( |,|$).*)/.match(field)
+        input_text.scan(/(?:input_field|field|return_field|connection|argument) .*$/).each do |field|
+          matches = /(?<field_type>input_field|return_field|field|connection|argument) :(?<name>[a-zA-Z_0-9_]*)?(:?, +(?<return_type>([A-Za-z\[\]\.\!_0-9\(\)]|::|-> ?\{ ?| ?\})+))?(?<remainder>( |,|$).*)/.match(field)
           if matches
             name = matches[:name]
             return_type = matches[:return_type]
@@ -543,7 +711,8 @@ module GraphQL
       end
 
       def apply(input_text)
-        if input_text =~ @interface_file_pattern && input_text =~ /\n *def /
+        # See if it its an interface file with any instance methods
+        if input_text =~ @interface_file_pattern && input_text =~ /\n *def (?!(self|[A-Z]))/
           # Extract the method bodies and figure out where the module should be inserted
           method_bodies = []
           processor = apply_processor(input_text, InterfaceMethodProcessor.new)
@@ -632,6 +801,9 @@ module GraphQL
 
       DEFAULT_TYPE_TRANSFORMS = [
         TypeDefineToClassTransform,
+        MutationResolveProcToMethodTransform, # Do this before switching to class, so we can detect that its a mutation
+        UnderscorizeMutationHashTransform,
+        MutationDefineToClassTransform,
         NameTransform,
         InterfacesToImplementsTransform,
         PossibleTypesTransform,
@@ -642,6 +814,7 @@ module GraphQL
 
       DEFAULT_FIELD_TRANSFORMS = [
         RemoveNewlinesTransform,
+        RemoveMethodParensTransform,
         PositionalTypeArgTransform,
         ConfigurationToKwargTransform.new(kwarg: "property"),
         ConfigurationToKwargTransform.new(kwarg: "description"),
@@ -719,9 +892,11 @@ module GraphQL
         # For each of the locations we found, extract the text for that definition.
         # The text will be transformed independently,
         # then the transformed text will replace the original text.
-        finder.locations.each do |name, (starting_idx, ending_idx)|
-          field_source = type_source[starting_idx..ending_idx]
-          field_sources << field_source
+        finder.locations.each do |category, locs|
+          locs.each do |name, (starting_idx, ending_idx)|
+            field_source = type_source[starting_idx..ending_idx]
+            field_sources << field_source
+          end
         end
         # Here's a crazy thing: the transformation is pure,
         # so definitions like `argument :id, types.ID` can be transformed once
@@ -739,13 +914,13 @@ module GraphQL
       class FieldFinder < Parser::AST::Processor
         # These methods are definition DSLs which may accept a block,
         # each of these definitions is passed for transformation in its own right
-        DEFINITION_METHODS = [:field, :connection, :input_field, :argument]
+        DEFINITION_METHODS = [:field, :connection, :input_field, :return_field, :argument]
         attr_reader :locations
 
         def initialize
-          # Pairs of `{ name => [start, end] }`,
-          # since we know fields are unique by name.
-          @locations = {}
+          # Pairs of `{ { method_name => { name => [start, end] } }`,
+          # since fields/arguments are unique by name, within their category
+          @locations = Hash.new { |h,k| h[k] = {} }
         end
 
         # @param send_node [node] The node which might be a `field` call, etc
@@ -757,10 +932,10 @@ module GraphQL
             name = arg_nodes[0]
             # This field may have already been added because
             # we find `(block ...)` nodes _before_ we find `(send ...)` nodes.
-            if @locations[name].nil?
+            if @locations[method_name][name].nil?
               starting_idx = source_node.loc.expression.begin.begin_pos
               ending_idx = source_node.loc.expression.end.end_pos
-              @locations[name] = [starting_idx, ending_idx]
+              @locations[method_name][name] = [starting_idx, ending_idx]
             end
           end
         end