graphql 1.8.7 → 1.9.0

data/spec/graphql/upgrader/member_spec.rb

@@ -292,6 +292,10 @@ RUBY
       new = %{field :name, String, null: false}
       assert_equal new, upgrade(old)
 
+      old = %{field :name, types.String.to_non_null_type}
+      new = %{field :name, String, null: false}
+      assert_equal new, upgrade(old)
+
       old = %{field :name, !types.String, "description", method: :name_full}
       new = %{field :name, String, "description", method: :name_full, null: false}
       assert_equal new, upgrade(old)
@@ -300,6 +304,10 @@ RUBY
       new = %{field :name, String, null: false}
       assert_equal new, upgrade(old)
 
+      old = %{field :name, -> { types.String.to_non_null_type }}
+      new = %{field :name, String, null: false}
+      assert_equal new, upgrade(old)
+
       old = %{connection :name, Name.connection_type, "names"}
       new = %{field :name, Name.connection_type, "names", null: true, connection: true}
       assert_equal new, upgrade(old)
@@ -308,10 +316,18 @@ RUBY
       new = %{field :name, Name.connection_type, "names", null: false, connection: true}
       assert_equal new, upgrade(old)
 
+      old = %{connection :name, Name.connection_type.to_non_null_type, "names"}
+      new = %{field :name, Name.connection_type, "names", null: false, connection: true}
+      assert_equal new, upgrade(old)
+
       old = %{field :names, types[!types.String]}
       new = %{field :names, [String], null: true}
       assert_equal new, upgrade(old)
 
+      old = %{field :names, types[types.String.to_non_null_type]}
+      new = %{field :names, [String], null: true}
+      assert_equal new, upgrade(old)
+
       old = %{field :names, !types[types.String]}
       new = %{field :names, [String, null: true], null: false}
       assert_equal new, upgrade(old)
@@ -341,6 +357,22 @@ RUBY
       }
       assert_equal new, upgrade(old)
 
+      old = %{
+        field :name, types.String.to_non_null_type do
+          description "abc"
+        end
+
+        field :name2, types.Int.to_non_null_type do
+          description "def"
+        end
+      }
+      new = %{
+        field :name, String, description: "abc", null: false
+
+        field :name2, Integer, description: "def", null: false
+      }
+      assert_equal new, upgrade(old)
+
       old = %{
         field :name, -> { !types.String } do
         end
@@ -350,6 +382,15 @@ RUBY
       }
       assert_equal new, upgrade(old)
 
+      old = %{
+        field :name, -> { types.String.to_non_null_type } do
+        end
+      }
+      new = %{
+        field :name, String, null: false
+      }
+      assert_equal new, upgrade(old)
+
       old = %{
         field :name do
           type -> { String }
@@ -376,6 +417,22 @@ RUBY
       }
       assert_equal new, upgrade(old)
 
+      old = %{
+        field :name do
+          type String.to_non_null_type
+        end
+
+        field :name2 do
+          type String.to_non_null_type
+        end
+      }
+      new = %{
+        field :name, String, null: false
+
+        field :name2, String, null: false
+      }
+      assert_equal new, upgrade(old)
+
       old = %{
         field :name, -> { types.String },
           "newline description" do
@@ -396,6 +453,16 @@ RUBY
       }
       assert_equal new, upgrade(old)
 
+      old = %{
+        field :name, -> { types.String.to_non_null_type },
+          "newline description" do
+        end
+      }
+      new = %{
+        field :name, String, "newline description", null: false
+      }
+      assert_equal new, upgrade(old)
+
       old = %{
        field :name, String,
          field: SomeField do

data/spec/{graphql → integration/mongoid/graphql}/relay/mongo_relation_connection_spec.rb

@@ -1,18 +1,7 @@
 # frozen_string_literal: true
 require 'spec_helper'
 
-if MONGO_DETECTED
-  require "support/star_trek/data"
-  require "support/star_trek/schema"
-end
-
 describe GraphQL::Relay::MongoRelationConnection do
-  before do
-    if !MONGO_DETECTED
-      skip("Mongo not detected")
-    end
-  end
-
   def get_names(result)
     ships = result["data"]["federation"]["bases"]["edges"]
     ships.map { |e| e["node"]["name"] }
@@ -71,19 +60,19 @@ describe GraphQL::Relay::MongoRelationConnection do
       assert_equal(2, get_names(result).length)
       assert_equal(true, get_page_info(result)["hasNextPage"])
       assert_equal(false, get_page_info(result)["hasPreviousPage"])
-      assert_equal("MQ==", get_page_info(result)["startCursor"])
-      assert_equal("Mg==", get_page_info(result)["endCursor"])
-      assert_equal("MQ==", get_first_cursor(result))
-      assert_equal("Mg==", get_last_cursor(result))
+      assert_equal("MQ", get_page_info(result)["startCursor"])
+      assert_equal("Mg", get_page_info(result)["endCursor"])
+      assert_equal("MQ", get_first_cursor(result))
+      assert_equal("Mg", get_last_cursor(result))
 
       result = star_trek_query(query_string, "first" => 3)
       assert_equal(3, get_names(result).length)
       assert_equal(false, get_page_info(result)["hasNextPage"])
       assert_equal(false, get_page_info(result)["hasPreviousPage"])
-      assert_equal("MQ==", get_page_info(result)["startCursor"])
-      assert_equal("Mw==", get_page_info(result)["endCursor"])
-      assert_equal("MQ==", get_first_cursor(result))
-      assert_equal("Mw==", get_last_cursor(result))
+      assert_equal("MQ", get_page_info(result)["startCursor"])
+      assert_equal("Mw", get_page_info(result)["endCursor"])
+      assert_equal("MQ", get_first_cursor(result))
+      assert_equal("Mw", get_last_cursor(result))
     end
 
     it 'provides custom fields on the connection type' do
@@ -279,7 +268,7 @@ describe GraphQL::Relay::MongoRelationConnection do
         assert_equal(first_and_second_names, get_names(result))
         assert_equal(false, result["data"]["federation"]["bases"]["pageInfo"]["hasPreviousPage"], "hasPreviousPage is false when last is not specified")
 
-        third_cursor = "Mw=="
+        third_cursor = "Mw"
         result = star_trek_query(query_string, "last" => 100, "before" => third_cursor)
         assert_equal(first_and_second_names, get_names(result))
 
@@ -473,8 +462,8 @@ describe GraphQL::Relay::MongoRelationConnection do
     let(:connection) { GraphQL::Relay::MongoRelationConnection.new(StarTrek::Base.where(faction_id: 1), {}) }
 
     it "returns the cursor for a node in the connection" do
-      assert_equal "MQ==", connection.cursor_from_node(StarTrek::Base.all[0])
-      assert_equal "Mg==", connection.cursor_from_node(StarTrek::Base.all[1])
+      assert_equal "MQ", connection.cursor_from_node(StarTrek::Base.all[0])
+      assert_equal "Mg", connection.cursor_from_node(StarTrek::Base.all[1])
     end
 
     it "raises when the node isn't found" do

data/spec/integration/mongoid/spec_helper.rb

@@ -0,0 +1,2 @@
+# frozen_string_literal: true
+require "mongoid" if RUBY_ENGINE == 'ruby'

data/spec/{support → integration/mongoid}/star_trek/schema.rb

@@ -79,18 +79,18 @@ module StarTrek
     end
   end
 
-  # Example of GraphQL::Function used with the connection helper:
-  class ShipsWithMaxPageSize < GraphQL::Function
-    argument :nameIncludes, GraphQL::STRING_TYPE
-    def call(obj, args, ctx)
-      all_ships = obj.ships.map { |ship_id| StarTrek::DATA["Ship"][ship_id] }
-      if args[:nameIncludes]
-        all_ships = all_ships.select { |ship| ship.name.include?(args[:nameIncludes])}
+
+  class ShipsWithMaxPageSize < GraphQL::Schema::Resolver
+    argument :name_includes, String, required: false
+    type Ship.connection_type, null: true
+
+    def resolve(name_includes: nil)
+      all_ships = object.ships.map { |ship_id| StarTrek::DATA["Ship"][ship_id] }
+      if name_includes
+        all_ships = all_ships.select { |ship| ship.name.include?(name_includes)}
       end
       all_ships
     end
-
-    type Ship.connection_type
   end
 
   class ShipConnectionWithParentType < GraphQL::Types::Relay::BaseConnection
@@ -107,10 +107,14 @@ module StarTrek
 
     field :id, ID, null: false, resolve: GraphQL::Relay::GlobalIdResolve.new(type: Faction)
     field :name, String, null: true
-    field :ships, ShipConnectionWithParentType, connection: true, max_page_size: 1000, null: true, resolve: ->(obj, args, ctx) {
-      all_ships = obj.ships.map {|ship_id| StarTrek::DATA["Ship"][ship_id] }
-      if args[:nameIncludes]
-        case args[:nameIncludes]
+    field :ships, ShipConnectionWithParentType, connection: true, max_page_size: 1000, null: true do
+      argument :name_includes, String, required: false
+    end
+
+    def ships(name_includes: nil)
+      all_ships = object.ships.map {|ship_id| StarTrek::DATA["Ship"][ship_id] }
+      if name_includes
+        case name_includes
         when "error"
           all_ships = GraphQL::ExecutionError.new("error from within connection")
         when "raisedError"
@@ -125,25 +129,24 @@ module StarTrek
           prev_all_ships = all_ships
           all_ships = LazyWrapper.new { prev_all_ships }
         else
-          all_ships = all_ships.select { |ship| ship.name.include?(args[:nameIncludes])}
+          all_ships = all_ships.select { |ship| ship.name.include?(name_includes)}
         end
       end
       all_ships
-    } do
-      # You can define arguments here and use them in the connection
-      argument :nameIncludes, String, required: false
     end
 
-    field :shipsWithMaxPageSize, "Ships with max page size", max_page_size: 2, function: ShipsWithMaxPageSize.new
+    field :shipsWithMaxPageSize, "Ships with max page size", max_page_size: 2, resolver: ShipsWithMaxPageSize
 
-    field :bases, BaseConnectionWithTotalCountType, null: true, connection: true, resolve: ->(obj, args, ctx) {
-      all_bases = obj.bases
-      if args[:nameIncludes]
-        all_bases = all_bases.where(name: Regexp.new(args[:nameIncludes]))
+    field :bases, BaseConnectionWithTotalCountType, null: true, connection: true do
+      argument :name_includes, String, required: false
+    end
+
+    def bases(name_includes: nil)
+      all_bases = object.bases
+      if name_includes
+        all_bases = all_bases.where(name: Regexp.new(name_includes))
       end
       all_bases
-    } do
-      argument :nameIncludes, String, required: false
     end
 
     field :basesClone, BaseType.connection_type, null: true
@@ -158,13 +161,24 @@ module StarTrek
       end
     end
 
-    field :basesWithMaxLimitRelation, BaseType.connection_type, null: true, max_page_size: 2, resolve: Proc.new { Base.all}
-    field :basesWithMaxLimitArray, BaseType.connection_type, null: true, max_page_size: 2, resolve: Proc.new { Base.all.to_a }
-    field :basesWithDefaultMaxLimitRelation, BaseType.connection_type, null: true, resolve: Proc.new { Base.all }
-    field :basesWithDefaultMaxLimitArray, BaseType.connection_type, null: true, resolve: Proc.new { Base.all.to_a }
-    field :basesWithLargeMaxLimitRelation, BaseType.connection_type, null: true, max_page_size: 1000, resolve: Proc.new { Base.all }
+    def all_bases
+      Base.all
+    end
+
+    def all_bases_array
+      all_bases.to_a
+    end
 
-    field :basesWithCustomEdge, CustomEdgeBaseConnectionType, null: true, connection: true, resolve: ->(o, a, c) { LazyNodesWrapper.new(o.bases) }
+    field :basesWithMaxLimitRelation, BaseType.connection_type, null: true, max_page_size: 2, resolver_method: :all_bases
+    field :basesWithMaxLimitArray, BaseType.connection_type, null: true, max_page_size: 2, resolver_method: :all_bases_array
+    field :basesWithDefaultMaxLimitRelation, BaseType.connection_type, null: true, resolver_method: :all_bases
+    field :basesWithDefaultMaxLimitArray, BaseType.connection_type, null: true, resolver_method: :all_bases_array
+    field :basesWithLargeMaxLimitRelation, BaseType.connection_type, null: true, max_page_size: 1000, resolver_method: :all_bases
+
+    field :basesWithCustomEdge, CustomEdgeBaseConnectionType, null: true, connection: true
+    def bases_with_custom_edge
+      LazyNodesWrapper.new(object.bases)
+    end
   end
 
   class IntroduceShipMutation < GraphQL::Schema::RelayClassicMutation
@@ -302,7 +316,9 @@ module StarTrek
 
     field :largestBase, BaseType, null: true, resolve: ->(obj, args, ctx) { Base.find(3) }
 
-    field :newestBasesGroupedByFaction, BaseType.connection_type, null: true, resolve: ->(obj, args, ctx) {
+    field :newestBasesGroupedByFaction, BaseType.connection_type, null: true
+
+    def newest_bases_grouped_by_faction
       agg = Base.collection.aggregate([{
         "$group" => {
           "_id" => "$faction_id",
@@ -312,11 +328,13 @@ module StarTrek
       Base.
         in(id: agg.map { |doc| doc['baseId'] }).
         order_by(faction_id: -1)
-    }
+    end
 
-    field :basesWithNullName, BaseType.connection_type, null: false, resolve: ->(obj, args, ctx) {
+    field :basesWithNullName, BaseType.connection_type, null: false
+
+    def bases_with_null_name
       [OpenStruct.new(id: nil)]
-    }
+    end
 
     field :node, field: GraphQL::Relay::Node.field
 
@@ -371,6 +389,10 @@ module StarTrek
     mutation(MutationType)
     default_max_page_size 3
 
+    if TESTING_INTERPRETER
+      use GraphQL::Execution::Interpreter
+    end
+
     def self.resolve_type(type, object, ctx)
       if object == :test_error
         :not_a_type

data/spec/{support/star_wars → integration/rails}/data.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require_relative 'spec_helper'
 require 'ostruct'
 
 # platform helper

data/spec/{generators → integration/rails/generators}/graphql/install_generator_spec.rb

@@ -19,7 +19,7 @@ class GraphQLGeneratorsInstallGeneratorTest < Rails::Generators::TestCase
 
     assert_file "app/graphql/types/.keep"
     assert_file "app/graphql/mutations/.keep"
-    ["base_object", "base_input_object", "base_enum", "base_union", "base_interface"].each do |base_type|
+    ["base_object", "base_input_object", "base_enum", "base_scalar", "base_union", "base_interface"].each do |base_type|
       assert_file "app/graphql/types/#{base_type}.rb"
     end
     expected_query_route = %|post "/graphql", to: "graphql#execute"|

data/spec/integration/rails/generators/graphql/scalar_generator_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+require "spec_helper"
+require "generators/graphql/scalar_generator"
+
+class GraphQLGeneratorsScalarGeneratorTest < BaseGeneratorTest
+  tests Graphql::Generators::ScalarGenerator
+
+  test "it generates scalar class" do
+    expected_content = <<-RUBY
+module Types
+  class DateType < Types::BaseScalar
+    def self.coerce_input(input_value, context)
+      # Override this to prepare a client-provided GraphQL value for your Ruby code
+      input_value
+    end
+
+    def self.coerce_result(ruby_value, context)
+      # Override this to serialize a Ruby value for the GraphQL response
+      ruby_value.to_s
+    end
+  end
+end
+RUBY
+
+    run_generator(["Date"])
+    assert_file "app/graphql/types/date_type.rb", expected_content
+  end
+end