graphql 1.8.0.pre6 → 1.8.0.pre7

data/lib/graphql/static_validation/rules/fields_have_appropriate_selections.rb

@@ -24,7 +24,11 @@ module GraphQL
         msg = if resolved_type.nil?
           nil
         elsif resolved_type.kind.scalar? && ast_node.selections.any?
-          "Selections can't be made on scalars (%{node_name} returns #{resolved_type.name} but has selections [#{ast_node.selections.map(&:name).join(", ")}])"
+          if ast_node.selections.first.is_a?(GraphQL::Language::Nodes::InlineFragment)
+            "Selections can't be made on scalars (%{node_name} returns #{resolved_type.name} but has inline fragments [#{ast_node.selections.map(&:type).map(&:name).join(", ")}])"
+          else
+            "Selections can't be made on scalars (%{node_name} returns #{resolved_type.name} but has selections [#{ast_node.selections.map(&:name).join(", ")}])"
+          end
         elsif resolved_type.kind.object? && ast_node.selections.none?
           "Objects must have selections (%{node_name} returns #{resolved_type.name} but has no selections)"
         else

data/lib/graphql/upgrader/member.rb

@@ -11,7 +11,6 @@ module GraphQL
 
     class Transform
       # @param input_text [String] Untransformed GraphQL-Ruby code
-      # @param rewrite_options [Hash] Used during rewrite
       # @return [String] The input text, with a transformation applied if necessary
       def apply(input_text)
         raise NotImplementedError, "Return transformed text here"
@@ -19,11 +18,11 @@ module GraphQL
 
       # Recursively transform a `.define`-DSL-based type expression into a class-ready expression, for example:
       #
-      # - `types[X]` -> `[X]`
+      # - `types[X]` -> `[X, null: true]`
       # - `Int` -> `Integer`
       # - `X!` -> `X`
       #
-      # Notice that `!` is removed entirely, because it doesn't exist in the class API.
+      # Notice that `!` is removed sometimes, because it doesn't exist in the class API.
       #
       # @param type_expr [String] A `.define`-ready expression of a return type or input type
       # @return [String] A class-ready expression of the same type`
@@ -34,7 +33,15 @@ module GraphQL
           "#{preserve_bang ? "!" : ""}#{normalize_type_expression(type_expr[1..-1], preserve_bang: preserve_bang)}"
         when /\Atypes\[.*\]\Z/
           # Unwrap the brackets, normalize, then re-wrap
-          "[#{normalize_type_expression(type_expr[6..-2], preserve_bang: preserve_bang)}]"
+          inner_type = type_expr[6..-2]
+          if inner_type.start_with?("!")
+            nullable = false
+            inner_type = inner_type[1..-1]
+          else
+            nullable = true
+          end
+
+          "[#{normalize_type_expression(inner_type, preserve_bang: preserve_bang)}#{nullable ? ", null: true" : ""}]"
         when /\Atypes\./
           # Remove the prefix
           normalize_type_expression(type_expr[6..-1], preserve_bang: preserve_bang)
@@ -326,8 +333,12 @@ module GraphQL
           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
-          proc_body.gsub!(/([^\w:]|^)#{obj_arg_name}([^\w]|$)/, '\1@object\2')
-          proc_body.gsub!(/([^\w:]|^)#{ctx_arg_name}([^\w]|$)/, '\1@context\2')
+          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
@@ -442,7 +453,7 @@ 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)
+          matches = /(?<field_type>input_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]
@@ -458,7 +469,6 @@ module GraphQL
               non_nullable = return_type.sub! /(^|[^\[])!/, '\1'
               nullable = !non_nullable
               return_type = normalize_type_expression(return_type)
-              return_type = return_type.gsub ',', ''
             else
               non_nullable = nil
               nullable = nil
@@ -516,15 +526,91 @@ module GraphQL
     # Remove redundant newlines, which may have trailing spaces
     # Remove double newline after `do`
     # Remove double newline before `end`
+    # Remove lines with whitespace only
     class RemoveExcessWhitespaceTransform < Transform
       def apply(input_text)
         input_text
           .gsub(/\n{3,}/m, "\n\n")
           .gsub(/do\n{2,}/m, "do\n")
           .gsub(/\n{2,}(\s*)end/m, "\n\\1end")
+          .gsub(/\n +\n/m, "\n\n")
       end
     end
 
+    class MoveInterfaceMethodsToImplementationTransform < Transform
+      def initialize(interface_file_pattern: /<.*Interface/)
+        @interface_file_pattern = interface_file_pattern
+      end
+
+      def apply(input_text)
+        if input_text =~ @interface_file_pattern && input_text =~ /\n *def /
+          # 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,
@@ -562,14 +648,15 @@ module GraphQL
         ConfigurationToKwargTransform.new(kwarg: "deprecation_reason"),
         ConfigurationToKwargTransform.new(kwarg: "hash_key"),
         PropertyToMethodTransform,
-        RemoveRedundantKwargTransform.new(kwarg: "hash_key"),
-        RemoveRedundantKwargTransform.new(kwarg: "method"),
         UnderscoreizeFieldNameTransform,
         ResolveProcToMethodTransform,
         UpdateMethodSignatureTransform,
+        RemoveRedundantKwargTransform.new(kwarg: "hash_key"),
+        RemoveRedundantKwargTransform.new(kwarg: "method"),
       ]
 
       DEFAULT_CLEAN_UP_TRANSFORMS = [
+        MoveInterfaceMethodsToImplementationTransform,
         RemoveExcessWhitespaceTransform,
         RemoveEmptyBlocksTransform,
       ]

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.8.0.pre6"
+  VERSION = "1.8.0.pre7"
 end

data/spec/fixtures/upgrader/starrable.original.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Platform
+  module Interfaces
+    Starrable = GraphQL::InterfaceType.define do
+      name "Starrable"
+      description "Things that can be starred."
+
+      global_id_field :id
+
+      field :viewerHasStarred, !types.Boolean do
+        description "Returns a boolean indicating whether the viewing user has starred this starrable."
+
+        resolve ->(object, arguments, context) do
+          if context[:viewer]
+            context[:viewer].starred?(object)
+          else
+            false
+          end
+        end
+      end
+
+      connection :stargazers, -> { !Connections::Stargazer } do
+        description "A list of users who have starred this starrable."
+
+        argument :orderBy, Inputs::StarOrder, "Order for connection"
+
+        resolve ->(object, arguments, context) do
+          scope = case object
+          when Repository
+            object.stars
+          when Gist
+            GistStar.where(gist_id: object.id)
+          end
+
+          table = scope.table_name
+          if order_by = arguments["orderBy"]
+            scope = scope.order("#{table}.#{order_by["field"]} #{order_by["direction"]}")
+          end
+
+          scope
+        end
+      end
+    end
+  end
+end

data/spec/fixtures/upgrader/starrable.transformed.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Platform
+  module Interfaces
+    class Starrable < Platform::Interfaces::Base
+      description "Things that can be starred."
+
+      global_id_field :id
+
+      field :viewer_has_starred, Boolean, description: "Returns a boolean indicating whether the viewing user has starred this starrable.", null: false
+
+      field :stargazers, Connections::Stargazer, description: "A list of users who have starred this starrable.", null: false, connection: true do
+        argument :order_by, Inputs::StarOrder, "Order for connection", required: false
+      end
+
+      module Implementation
+        def viewer_has_starred
+          if @context[:viewer]
+            @context[:viewer].starred?(@object)
+          else
+            false
+          end
+        end
+
+        def stargazers(**arguments)
+          scope = case @object
+          when Repository
+            @object.stars
+          when Gist
+            GistStar.where(gist_id: @object.id)
+          end
+
+          table = scope.table_name
+          if order_by = arguments[:order_by]
+            scope = scope.order("#{table}.#{order_by["field"]} #{order_by["direction"]}")
+          end
+
+          scope
+        end
+      end
+    end
+  end
+end

data/spec/fixtures/upgrader/subscribable.transformed.rb

@@ -9,42 +9,44 @@ module Platform
 
       field :viewer_subscription, Enums::SubscriptionState, description: "Identifies if the viewer is watching, not watching, or ignoring the subscribable entity.", null: false
 
-      def viewer_subscription
-        if @context[:viewer].nil?
-          return "unsubscribed"
-        end
+      field :viewer_can_subscribe, Boolean, description: "Check if the viewer is able to change their subscription status for the repository.", null: false
 
-        subscription_status_response = @object.async_subscription_status(@context[:viewer]).sync
+      field :issues, function: Platform::Functions::Issues.new, description: "A list of issues associated with the milestone.", connection: true
+      field :files, Connections.define(PackageFile), description: "List of files associated with this registry package version", null: false, connection: true
+      field :enabled, Boolean, "Whether enabled for this project", method: :enabled?, null: false
 
-        if subscription_status_response.failed?
-          error = Platform::Errors::ServiceUnavailable.new("Subscriptions are currently unavailable. Please try again later.")
-          error.ast_node = @context.irep_node.ast_node
-          error.path = @context.path
-          @context.errors << error
-          return "unavailable"
+      module Implementation
+        def viewer_subscription
+          if @context[:viewer].nil?
+            return "unsubscribed"
+          end
+
+          subscription_status_response = @object.async_subscription_status(@context[:viewer]).sync
+
+          if subscription_status_response.failed?
+            error = Platform::Errors::ServiceUnavailable.new("Subscriptions are currently unavailable. Please try again later.")
+            error.ast_node = @context.irep_node.ast_node
+            error.path = @context.path
+            @context.errors << error
+            return "unavailable"
+          end
+
+          subscription = subscription_status_response.value
+          if subscription.included?
+            "unsubscribed"
+          elsif subscription.subscribed?
+            "subscribed"
+          elsif subscription.ignored?
+            "ignored"
+          end
         end
 
-        subscription = subscription_status_response.value
-        if subscription.included?
-          "unsubscribed"
-        elsif subscription.subscribed?
-          "subscribed"
-        elsif subscription.ignored?
-          "ignored"
-        end
-      end
+        def viewer_can_subscribe
+          return false if @context[:viewer].nil?
 
-      field :viewer_can_subscribe, Boolean, description: "Check if the viewer is able to change their subscription status for the repository.", null: false
-
-      def viewer_can_subscribe
-        return false if @context[:viewer].nil?
-
-        @object.async_subscription_status(@context[:viewer]).then(&:success?)
+          @object.async_subscription_status(@context[:viewer]).then(&:success?)
+        end
       end
-
-      field :issues, function: Platform::Functions::Issues.new, description: "A list of issues associated with the milestone.", connection: true
-      field :files, Connections.define(PackageFile), description: "List of files associated with this registry package version", null: false, connection: true
-      field :enabled, Boolean, "Whether enabled for this project", method: :enabled?, null: false
     end
   end
 end

data/spec/fixtures/upgrader/type_x.original.rb

@@ -11,8 +11,8 @@ module Platform
       global_id_field :id
       interfaces [GraphQL::Relay::Node.interface]
 
-      field :f1, !Objects::O1, "The x being y."
-      field :f2, !Enums::E1, "x for the y.",
+      field :f1,    !Objects::O1, "The x being y."
+      field :f2,    !Enums::E1, "x for the y.",
         property: :field_2
       field :f3, Enums::E2, "x for y."
       field :details, types.String, "Details."
@@ -48,6 +48,18 @@ module Platform
 
       field :f7, field: SomeField
       field :f8, function: SomeFunction
+      field :f9, types[Objects::O2]
+      field :fieldField, types.String, hash_key: "fieldField"
+      field :fieldField2, types.String, property: :field_field2
+
+      field :f10, types.String do
+        resolve ->(obj, _, _) do
+          obj.something do |_|
+            xyz_obj.obj
+            obj.f10
+          end
+        end
+      end
     end
   end
 end

data/spec/fixtures/upgrader/type_x.transformed.rb

@@ -39,6 +39,18 @@ module Platform
 
       field :f7, field: SomeField
       field :f8, function: SomeFunction
+      field :f9, [Objects::O2, null: true], null: true
+      field :field_field, String, hash_key: "fieldField", null: true
+      field :field_field2, String, null: true
+
+      field :f10, String, null: true
+
+      def f10
+        @object.something do |_|
+          xyz_obj.obj
+          @object.f10
+        end
+      end
     end
   end
 end

data/spec/graphql/query/executor_spec.rb

@@ -188,7 +188,8 @@ describe GraphQL::Query::Executor do
 
     describe "if the schema has a rescue handler" do
       before do
-        schema.rescue_from(RuntimeError) { "Error was handled!" }
+        # HACK: reach to the underlying instance to perform a side-effect
+        schema.graphql_definition.rescue_from(RuntimeError) { "Error was handled!" }
       end
 
       after do

data/spec/graphql/rake_task_spec.rb

@@ -34,7 +34,9 @@ describe GraphQL::RakeTask do
       end
       dumped_json = File.read("./schema.json")
       expected_json = JSON.pretty_generate(RakeTaskSchema.execute(GraphQL::Introspection::INTROSPECTION_QUERY))
-      assert_equal(expected_json, dumped_json)
+
+      # Test that that JSON is logically equivalent, not serialized the same
+      assert_equal(JSON.parse(expected_json), JSON.parse(dumped_json))
 
       dumped_idl = File.read("./schema.graphql")
       expected_idl = rake_task_schema_defn.chomp

data/spec/graphql/schema/field_spec.rb

@@ -11,8 +11,17 @@ describe GraphQL::Schema::Field do
       assert_equal :ok, arg_defn.metadata[:custom]
     end
 
-    it "camelizes the field name" do
+    it "camelizes the field name, unless camelize: false" do
       assert_equal 'inspectInput', field.graphql_definition.name
+
+      underscored_field = GraphQL::Schema::Field.new(:underscored_field, String, null: false, camelize: false) do
+        argument :underscored_arg, String, required: true, camelize: false
+      end
+
+      assert_equal 'underscored_field', underscored_field.to_graphql.name
+      arg_name, arg_defn = underscored_field.to_graphql.arguments.first
+      assert_equal 'underscored_arg', arg_name
+      assert_equal 'underscored_arg', arg_defn.name
     end
 
     it "exposes the method override" do
@@ -36,5 +45,89 @@ describe GraphQL::Schema::Field do
       assert_equal "test", object.fields["test"].arguments["test"].name
       assert_equal "A Description.", object.fields["test"].description
     end
+
+    describe "extras" do
+      it "can get errors, which adds path" do
+        query_str = <<-GRAPHQL
+        query {
+          find(id: "Musician/Herbie Hancock") {
+            ... on Musician {
+              addError
+            }
+          }
+        }
+        GRAPHQL
+
+        res = Jazz::Schema.execute(query_str)
+        err = res["errors"].first
+        assert_equal "this has a path", err["message"]
+        assert_equal ["find", "addError"], err["path"]
+        assert_equal [{"line"=>4, "column"=>15}], err["locations"]
+      end
+    end
+
+    describe "complexity" do
+      it "accepts a keyword argument" do
+        object = Class.new(Jazz::BaseObject) do
+          graphql_name "complexityKeyword"
+
+          field :complexityTest, String, null: true, complexity: 25
+        end.to_graphql
+
+        assert_equal 25, object.fields["complexityTest"].complexity
+      end
+
+      it "accepts a proc in the definition block" do
+        object = Class.new(Jazz::BaseObject) do
+          graphql_name "complexityKeyword"
+
+          field :complexityTest, String, null: true do
+            complexity ->(_ctx, _args, _child_complexity) { 52 }
+          end
+        end.to_graphql
+
+        assert_equal 52, object.fields["complexityTest"].complexity.call(nil, nil, nil)
+      end
+
+      it "accepts an integer in the definition block" do
+        object = Class.new(Jazz::BaseObject) do
+          graphql_name "complexityKeyword"
+
+          field :complexityTest, String, null: true do
+            complexity 38
+          end
+        end.to_graphql
+
+        assert_equal 38, object.fields["complexityTest"].complexity
+      end
+
+      it 'fails if the complexity is not numeric and not a proc' do
+        err = assert_raises(RuntimeError) do
+          Class.new(Jazz::BaseObject) do
+            graphql_name "complexityKeyword"
+
+            field :complexityTest, String, null: true do
+              complexity 'One hundred and eighty'
+            end
+          end.to_graphql
+        end
+
+        assert_match /^Invalid complexity:/, err.message
+      end
+
+      it 'fails if the proc does not accept 3 parameters' do
+        err = assert_raises(RuntimeError) do
+          Class.new(Jazz::BaseObject) do
+            graphql_name "complexityKeyword"
+
+            field :complexityTest, String, null: true do
+              complexity ->(one, two) { 52 }
+            end
+          end.to_graphql
+        end
+
+        assert_match /^A complexity proc should always accept 3 parameters/, err.message
+      end
+    end
   end
 end