graphql 1.8.0.pre10 → 1.8.0.pre11

data/lib/graphql/schema/relay_classic_mutation.rb

@@ -23,7 +23,21 @@ module GraphQL
       # The payload should always include this field
       field(:client_mutation_id, String, "A unique identifier for the client performing the mutation.", null: true)
 
+
+      # Override {GraphQL::Schema::Mutation#resolve_mutation} to
+      # delete `client_mutation_id` from the kwargs.
+      def resolve_mutation(kwargs)
+        # This is handled by Relay::Mutation::Resolve, a bit hacky, but here we are.
+        kwargs.delete(:client_mutation_id)
+        super
+      end
+
       class << self
+        def inherited(base)
+          base.null(true)
+          super
+        end
+
         # 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})
@@ -68,17 +82,6 @@ module GraphQL
             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

data/lib/graphql/schema/rescue_middleware.rb

@@ -41,13 +41,14 @@ module GraphQL
       private
 
       def attempt_rescue(err)
-        handler = rescue_table[err.class]
-        if handler
-          message = handler.call(err)
-          GraphQL::ExecutionError.new(message)
-        else
-          raise(err)
-        end
+        rescue_table.each { |klass, handler|
+          if klass.is_a?(Class) && err.is_a?(klass) && handler
+            message = handler.call(err)
+            return GraphQL::ExecutionError.new(message)
+          end
+        }
+
+        raise(err)
       end
     end
   end

data/lib/graphql/schema/scalar.rb

@@ -5,12 +5,15 @@ module GraphQL
       extend GraphQL::Schema::Member::AcceptsDefinition
 
       class << self
+        extend Forwardable
+        def_delegators :graphql_definition, :coerce_isolated_input, :coerce_isolated_result
+
         def coerce_input(val, ctx)
-          raise NotImplementedError, "#{self.name}.coerce_input(val, ctx) must prepare GraphQL input (#{val.inspect}) for Ruby processing"
+          val
         end
 
         def coerce_result(val, ctx)
-          raise NotImplementedError, "#{self.name}.coerce_result(val, ctx) must prepare Ruby value (#{val.inspect}) for GraphQL response"
+          val
         end
 
         def to_graphql
@@ -22,6 +25,10 @@ module GraphQL
           type_defn.metadata[:type_class] = self
           type_defn
         end
+
+        def kind
+          GraphQL::TypeKinds::SCALAR
+        end
       end
     end
   end

data/lib/graphql/schema/union.rb

@@ -26,6 +26,10 @@ module GraphQL
           type_defn.metadata[:type_class] = self
           type_defn
         end
+
+        def kind
+          GraphQL::TypeKinds::UNION
+        end
       end
     end
   end

data/lib/graphql/static_validation/definition_dependencies.rb

@@ -103,7 +103,7 @@ module GraphQL
       end
 
       class NodeWithPath
-        extend GraphQL::Delegate
+        extend Forwardable
         attr_reader :node, :path
         def initialize(node, path)
           @node = node

data/lib/graphql/static_validation/literal_validator.rb

@@ -16,23 +16,35 @@ module GraphQL
         elsif type.kind.list?
           item_type = type.of_type
           ensure_array(ast_value).all? { |val| validate(val, item_type) }
-        elsif type.kind.scalar? && !ast_value.is_a?(GraphQL::Language::Nodes::AbstractNode) && !ast_value.is_a?(Array)
+        elsif ast_value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
+          true
+        elsif type.kind.scalar? && constant_scalar?(ast_value)
           type.valid_input?(ast_value, @context)
         elsif type.kind.enum? && ast_value.is_a?(GraphQL::Language::Nodes::Enum)
           type.valid_input?(ast_value.name, @context)
         elsif type.kind.input_object? && ast_value.is_a?(GraphQL::Language::Nodes::InputObject)
           required_input_fields_are_present(type, ast_value) &&
             present_input_field_values_are_valid(type, ast_value)
-        elsif ast_value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
-          true
         else
           false
         end
       end
 
-
       private
 
+      # The GraphQL grammar supports variables embedded within scalars but graphql.js
+      # doesn't support it so we won't either for simplicity
+      def constant_scalar?(ast_value)
+        if ast_value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
+          false
+        elsif ast_value.is_a?(Array)
+          ast_value.all? { |element| constant_scalar?(element) }
+        elsif ast_value.is_a?(GraphQL::Language::Nodes::InputObject)
+          ast_value.arguments.all? { |arg| constant_scalar?(arg.value) }
+        else
+          true
+        end
+      end
 
       def required_input_fields_are_present(type, ast_node)
         required_field_names = @warden.arguments(type)

data/lib/graphql/static_validation/validation_context.rb

@@ -12,7 +12,7 @@ module GraphQL
     # It also provides limited access to the {TypeStack} instance,
     # which tracks state as you climb in and out of different fields.
     class ValidationContext
-      extend GraphQL::Delegate
+      extend Forwardable
 
       attr_reader :query, :schema,
         :document, :errors, :visitor,

data/lib/graphql/subscriptions.rb

@@ -9,6 +9,13 @@ end
 
 module GraphQL
   class Subscriptions
+    # Raised when either:
+    # - the triggered `event_name` doesn't match a field in the schema; or
+    # - one or more arguments don't match the field arguments
+    class InvalidTriggerError < GraphQL::Error
+    end
+
+    # @see {Subscriptions#initialize} for options, concrete implementations may add options.
     def self.use(defn, options = {})
       schema = defn.target
       options[:schema] = schema
@@ -19,8 +26,9 @@ module GraphQL
       nil
     end
 
-    def initialize(kwargs)
-      @schema = kwargs[:schema]
+    # @param schema [Class] the GraphQL schema this manager belongs to
+    def initialize(schema:, **rest)
+      @schema = schema
     end
 
     # Fetch subscriptions matching this field + arguments pair
@@ -31,31 +39,35 @@ module GraphQL
     # @param scope [Symbol, String]
     # @return [void]
     def trigger(event_name, args, object, scope: nil)
+      event_name = event_name.to_s
+
+      # Try with the verbatim input first:
       field = @schema.get_field("Subscription", event_name)
-      if !field
-        raise "No subscription matching trigger: #{event_name}"
-      end
 
-      # Normalize symbol-keyed args to strings
-      if args.any?
-        stringified_args = {}
-        args.each { |k, v| stringified_args[k.to_s] = v }
-        args = stringified_args
+      if field.nil?
+        # And if it wasn't found, normalize it:
+        normalized_event_name = normalize_name(event_name)
+        field = @schema.get_field("Subscription", normalized_event_name)
+        if field.nil?
+          raise InvalidTriggerError, "No subscription matching trigger: #{event_name} (looked for #{@schema.subscription.graphql_name}.#{normalized_event_name})"
+        end
+      else
+        # Since we found a field, the original input was already normalized
+        normalized_event_name = event_name
       end
 
+      # Normalize symbol-keyed args to strings, try camelizing them
+      normalized_args = normalize_arguments(normalized_event_name, field, args)
+
       event = Subscriptions::Event.new(
-        name: event_name,
-        arguments: args,
+        name: normalized_event_name,
+        arguments: normalized_args,
         field: field,
         scope: scope,
       )
       execute_all(event, object)
     end
 
-    def initialize(schema:, **rest)
-      @schema = schema
-    end
-
     # `event` was triggered on `object`, and `subscription_id` was subscribed,
     # so it should be updated.
     #
@@ -139,5 +151,67 @@ module GraphQL
     def build_id
       SecureRandom.uuid
     end
+
+    # Convert a user-provided event name or argument
+    # to the equivalent in GraphQL.
+    #
+    # By default, it converts the identifier to camelcase.
+    # Override this in a subclass to change the transformation.
+    #
+    # @param event_or_arg_name [String, Symbol]
+    # @return [String]
+    def normalize_name(event_or_arg_name)
+      Schema::Member::BuildType.camelize(event_or_arg_name.to_s)
+    end
+
+    private
+
+    # Recursively normalize `args` as belonging to `arg_owner`:
+    # - convert symbols to strings,
+    # - if needed, camelize the string (using {#normalize_name})
+    # @param arg_owner [GraphQL::Field, GraphQL::BaseType]
+    # @param args [Hash, Array, Any] some GraphQL input value to coerce as `arg_owner`
+    # @return [Any] normalized arguments value
+    def normalize_arguments(event_name, arg_owner, args)
+      case arg_owner
+      when GraphQL::Field, GraphQL::InputObjectType
+        normalized_args = {}
+        missing_arg_names = []
+        args.each do |k, v|
+          arg_name = k.to_s
+          arg_defn = arg_owner.arguments[arg_name]
+          if arg_defn
+            normalized_arg_name = arg_name
+          else
+            normalized_arg_name = normalize_name(arg_name)
+            arg_defn = arg_owner.arguments[normalized_arg_name]
+          end
+
+          if arg_defn
+            normalized_args[normalized_arg_name] = normalize_arguments(event_name, arg_defn.type, v)
+          else
+            # Couldn't find a matching argument definition
+            missing_arg_names << arg_name
+          end
+        end
+
+        if missing_arg_names.any?
+          arg_owner_name = if arg_owner.is_a?(GraphQL::Field)
+            "Subscription.#{arg_owner.name}"
+          else
+            arg_owner.to_s
+          end
+          raise InvalidTriggerError, "Can't trigger Subscription.#{event_name}, received undefined arguments: #{missing_arg_names.join(", ")}. (Should match arguments of #{arg_owner_name}.)"
+        end
+
+        normalized_args
+      when GraphQL::ListType
+        args.map { |a| normalize_arguments(event_name, arg_owner.of_type, a) }
+      when GraphQL::NonNullType
+        normalize_arguments(event_name, arg_owner.of_type, args)
+      else
+        args
+      end
+    end
   end
 end

data/lib/graphql/upgrader/member.rb

@@ -97,13 +97,18 @@ module GraphQL
     # Turns `{X} = GraphQL::{Y}Type.define do` into `class {X} < Types::Base{Y}`.
     class TypeDefineToClassTransform < Transform
       # @param base_class_pattern [String] Replacement pattern for the base class name. Use this if your base classes have nonstandard names.
-      def initialize(base_class_pattern: "Types::Base\\2")
-        @find_pattern = /([a-zA-Z_0-9:]*) = GraphQL::#{GRAPHQL_TYPES}Type\.define do/
-        @replace_pattern = "class \\1 < #{base_class_pattern}"
+      def initialize(base_class_pattern: "Types::Base\\3")
+        @find_pattern = /( *)([a-zA-Z_0-9:]*) = GraphQL::#{GRAPHQL_TYPES}Type\.define do/
+        @replace_pattern = "\\1class \\2 < #{base_class_pattern}"
+        @interface_replace_pattern = "\\1module \\2\n\\1  include #{base_class_pattern}"
       end
 
       def apply(input_text)
-        input_text.sub(@find_pattern, @replace_pattern)
+        if input_text.include?("GraphQL::InterfaceType.define")
+          input_text.sub(@find_pattern, @interface_replace_pattern)
+        else
+          input_text.sub(@find_pattern, @replace_pattern)
+        end
       end
     end
 
@@ -124,7 +129,12 @@ module GraphQL
     # Or, if it is not redundant, move it to `graphql_name "Something"`.
     class NameTransform < Transform
       def apply(transformable)
-        if (matches = transformable.match(/class (?<type_name>[a-zA-Z_0-9:]*) </))
+        last_type_defn = transformable
+          .split("\n")
+          .select { |line| line.include?("class ") || line.include?("module ")}
+          .last
+
+        if last_type_defn && (matches = last_type_defn.match(/(class|module) (?<type_name>[a-zA-Z_0-9:]*)( <|$)/))
           type_name = matches[:type_name]
           # Get the name without any prefixes or suffixes
           type_name_without_the_type_part = type_name.split('::').last.gsub(/Type$/, '')
@@ -151,7 +161,8 @@ module GraphQL
         keep_looking = true
         while keep_looking do
           keep_looking = false
-          input_text = input_text.gsub(/(?<field>(?:field|input_field|return_field|connection|argument)(?:\(.*|.*,))\n\s*(?<next_line>.+)/) do
+          # Find the `field` call (or other method), and an open paren, but not a close paren, or a comma between arguments
+          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]
@@ -167,8 +178,8 @@ module GraphQL
     class RemoveMethodParensTransform < Transform
       def apply(input_text)
         input_text.sub(
-          /(field|input_field|return_field|connection|argument)\( *(.*?) *\) */,
-          '\1 \2'
+          /(field|input_field|return_field|connection|argument)\( *(.*?) *\)( *)/,
+          '\1 \2\3'
         )
       end
     end
@@ -475,7 +486,7 @@ module GraphQL
 
     class ResolveProcToMethodTransform < Transform
       def apply(input_text)
-        if input_text =~ /resolve ->/
+        if input_text =~ /resolve\(? ?->/
           # - Find the proc literal
           # - Get the three argument names (obj, arg, ctx)
           # - Get the proc body
@@ -572,7 +583,8 @@ 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
+          # 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?
             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
@@ -705,81 +717,6 @@ module GraphQL
       end
     end
 
-    class MoveInterfaceMethodsToImplementationTransform < Transform
-      def initialize(interface_file_pattern: /<.*Interface/)
-        @interface_file_pattern = interface_file_pattern
-      end
-
-      def apply(input_text)
-        # 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)
-          processor.methods.each do |(begin_pos, end_pos)|
-            # go all the way back to the newline so we get whitespace too
-            while input_text[begin_pos] != "\n" && begin_pos >= 0
-              begin_pos -= 1
-            end
-            # Tuck away the method body, and remove it from here
-            method_body = input_text[begin_pos..end_pos]
-            method_bodies << method_body
-          end
-          # How far are these method bodies indented? The module will be this indented
-          leading_indent = method_bodies.first[/\n +/][1..-1]
-          # Increase the indent since it will be in a nested module
-          indented_method_bodies = method_bodies.map {|m| m.gsub("\n", "\n  ").rstrip }
-          # Build the ruby module definition
-          module_body = "\n\n#{leading_indent}module Implementation#{indented_method_bodies.join("\n")}\n#{leading_indent}end"
-
-          # find the `end` of the class definition, and put the module before it
-          _class_start, class_end = processor.class_definition
-          # This might target the newline _after_ `end`, but we don't want that one
-          if input_text[class_end] == "\n"
-            class_end -= 1
-          end
-
-          while input_text[class_end] != "\n" && class_end > 0
-            class_end -= 1
-          end
-
-          input_text.insert(class_end, module_body)
-
-          # Do the replacement _after_ identifying the bodies,
-          # otherwise the offsets get messed up
-          method_bodies.each do |method_body|
-            input_text.sub!(method_body, "")
-          end
-        end
-        input_text
-      end
-
-      # Find the beginning and end of each method def,
-      # so that we can move it wholesale
-      class InterfaceMethodProcessor < Parser::AST::Processor
-        attr_reader :methods, :class_definition
-        def initialize
-          @class_definition = nil
-          @methods = []
-          super
-        end
-
-        def on_def(node)
-          start = node.loc.expression.begin_pos
-          finish = node.loc.expression.end_pos
-          @methods << [start, finish]
-          super(node)
-        end
-
-        def on_class(node)
-          @class_definition = [
-            node.loc.expression.begin_pos,
-            node.loc.expression.end_pos
-          ]
-          super(node)
-        end
-      end
-    end
     # Skip this file if you see any `field`
     # helpers with `null: true` or `null: false` keywords
     # or `argument` helpers with `required:` keywords,
@@ -829,7 +766,6 @@ module GraphQL
       ]
 
       DEFAULT_CLEAN_UP_TRANSFORMS = [
-        MoveInterfaceMethodsToImplementationTransform,
         RemoveExcessWhitespaceTransform,
         RemoveEmptyBlocksTransform,
       ]
@@ -892,8 +828,8 @@ 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 |category, locs|
-          locs.each do |name, (starting_idx, ending_idx)|
+        FieldFinder::DEFINITION_METHODS.each do |def_method|
+          finder.locations[def_method].each do |name, (starting_idx, ending_idx)|
             field_source = type_source[starting_idx..ending_idx]
             field_sources << field_source
           end
@@ -913,7 +849,9 @@ 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
+        # each of these definitions is passed for transformation in its own right.
+        # `field` and `connection` take priority. In fact, they upgrade their
+        # own arguments, so those upgrades turn out to be no-ops.
         DEFINITION_METHODS = [:field, :connection, :input_field, :return_field, :argument]
         attr_reader :locations