graphql 1.5.15 → 1.6.0

data/spec/graphql/relay/connection_instrumentation_spec.rb

@@ -57,4 +57,27 @@ describe GraphQL::Relay::ConnectionInstrumentation do
     assert_instance_of GraphQL::Relay::ConnectionResolve, connection_field.resolve_proc
     assert_instance_of GraphQL::Relay::ConnectionResolve, redefined_connection_field.resolve_proc
   end
+
+  describe "after_built_ins instrumentation" do
+    it "has access to connection objects" do
+      query_str = <<-GRAPHQL
+      {
+        rebels {
+          ships {
+            pageInfo {
+              __typename
+            }
+          }
+        }
+      }
+      GRAPHQL
+      ctx = { before_built_ins: [], after_built_ins: [] }
+      star_wars_query(query_str, {}, context: ctx)
+      # The second item is different here:
+      # Before the object is wrapped in a connection, the instrumentation sees `Array`
+      assert_equal ["StarWars::FactionRecord", "Array", "GraphQL::Relay::ArrayConnection"], ctx[:before_built_ins]
+      # After the object is wrapped in a connection, it sees the connection object
+      assert_equal ["StarWars::FactionRecord", "GraphQL::Relay::ArrayConnection", "GraphQL::Relay::ArrayConnection"], ctx[:after_built_ins]
+    end
+  end
 end

data/spec/graphql/relay/mutation_spec.rb

@@ -282,11 +282,7 @@ describe GraphQL::Relay::Mutation do
 
       expected = {
         "data" => {
-          "introduceShip" => {
-            "clientMutationId" => "5678",
-            "shipEdge" => nil,
-            "faction" => nil,
-          }
+          "introduceShip" => nil,
         },
         "errors" => [
           {
@@ -305,11 +301,7 @@ describe GraphQL::Relay::Mutation do
 
       expected = {
         "data" => {
-          "introduceShip" => {
-            "clientMutationId" => "5678",
-            "shipEdge" => nil,
-            "faction" => nil,
-          }
+          "introduceShip" => nil,
         },
         "errors" => [
           {

data/spec/graphql/relay/page_info_spec.rb

@@ -75,8 +75,8 @@ describe GraphQL::Relay::PageInfo do
       result = star_wars_query(query_string, "last" => 1, "first" => 1, "before" => cursor_of_last_base)
       assert_equal(true, get_page_info(result)["hasNextPage"])
       assert_equal(true, get_page_info(result)["hasPreviousPage"])
-      assert_equal("Mg==", get_page_info(result)["startCursor"])
-      assert_equal("Mg==", get_page_info(result)["endCursor"])
+      assert_equal("MQ==", get_page_info(result)["startCursor"])
+      assert_equal("MQ==", get_page_info(result)["endCursor"])
     end
 
     it "startCursor and endCursor are the cursors of the first and last edge" do

data/spec/graphql/relay/relation_connection_spec.rb

@@ -104,6 +104,25 @@ describe GraphQL::Relay::RelationConnection do
       assert_equal(false, result["data"]["empire"]["bases"]["pageInfo"]["hasPreviousPage"])
     end
 
+    it 'works with before and after specified together' do
+      result = star_wars_query(query_string, "first" => 2)
+      assert_equal(["Death Star", "Shield Generator"], get_names(result))
+
+      first_cursor = get_last_cursor(result)
+
+      # There is no records between before and after if they point to the same cursor
+      result = star_wars_query(query_string, "before" => first_cursor, "after" => first_cursor, "last" => 2)
+      assert_equal([], get_names(result))
+
+      result = star_wars_query(query_string, "after" => first_cursor, "first" => 2)
+      assert_equal(["Headquarters"], get_names(result))
+
+      second_cursor = get_last_cursor(result)
+
+      result = star_wars_query(query_string, "after" => first_cursor, "before" => second_cursor, "first" => 3)
+      assert_equal([], get_names(result))
+    end
+
     it 'handles cursors beyond the bounds of the array' do
       overreaching_cursor = Base64.strict_encode64("100")
       result = star_wars_query(query_string, "after" => overreaching_cursor, "first" => 2)
@@ -186,18 +205,19 @@ describe GraphQL::Relay::RelationConnection do
       end
 
       it "applies to queries by `last`" do
-        last_cursor = "Ng=="
         second_to_last_two_names = ["Death Star", "Shield Generator"]
+        first_and_second_names = ["Yavin", "Echo Base"]
+
+        last_cursor = "Ng=="
         result = star_wars_query(query_string, "last" => 100, "before" => last_cursor)
         assert_equal(second_to_last_two_names, get_names(result))
         assert_equal(true, result["data"]["empire"]["bases"]["pageInfo"]["hasPreviousPage"])
 
         result = star_wars_query(query_string, "before" => last_cursor)
-        assert_equal(second_to_last_two_names, get_names(result))
+        assert_equal(first_and_second_names, get_names(result))
         assert_equal(false, result["data"]["empire"]["bases"]["pageInfo"]["hasPreviousPage"], "hasPreviousPage is false when last is not specified")
 
         third_cursor = "Mw=="
-        first_and_second_names = ["Yavin", "Echo Base"]
         result = star_wars_query(query_string, "last" => 100, "before" => third_cursor)
         assert_equal(first_and_second_names, get_names(result))
 
@@ -400,4 +420,148 @@ describe GraphQL::Relay::RelationConnection do
     connection = GraphQL::Relay::BaseConnection.connection_for_nodes(relation)
     assert_equal GraphQL::Relay::RelationConnection, connection
   end
+
+  describe "for an ActiveRecord::Relation" do
+    describe "#edge_nodes" do
+      it "returns the nodes for the current page" do
+        # Offset
+        connection = GraphQL::Relay::RelationConnection.new(StarWars::Base.offset(2), {})
+        assert_equal [StarWars::Base.find(3), StarWars::Base.find(4), StarWars::Base.find(5), StarWars::Base.find(6)], connection.edge_nodes,
+
+        cursor1 = connection.cursor_from_node(StarWars::Base.find(3))
+        cursor2 = connection.cursor_from_node(StarWars::Base.find(4))
+        cursor3 = connection.cursor_from_node(StarWars::Base.find(5))
+        cursor4 = connection.cursor_from_node(StarWars::Base.find(6))
+
+        connection = GraphQL::Relay::RelationConnection.new(StarWars::Base.offset(2), { first: 3 })
+        assert_equal [StarWars::Base.find(3), StarWars::Base.find(4), StarWars::Base.find(5)], connection.edge_nodes
+
+        assert_equal cursor1, connection.cursor_from_node(StarWars::Base.find(3))
+        assert_equal cursor2, connection.cursor_from_node(StarWars::Base.find(4))
+        assert_equal cursor3, connection.cursor_from_node(StarWars::Base.find(5))
+
+        connection = GraphQL::Relay::RelationConnection.new(StarWars::Base.offset(2), { last: 3 })
+        assert_equal [StarWars::Base.find(4), StarWars::Base.find(5), StarWars::Base.find(6)], connection.edge_nodes
+
+        assert_equal cursor2, connection.cursor_from_node(StarWars::Base.find(4))
+        assert_equal cursor3, connection.cursor_from_node(StarWars::Base.find(5))
+        assert_equal cursor4, connection.cursor_from_node(StarWars::Base.find(6))
+
+        connection = GraphQL::Relay::RelationConnection.new(StarWars::Base.offset(2), { last: 2 })
+        assert_equal [StarWars::Base.find(5), StarWars::Base.find(6)], connection.edge_nodes
+
+        assert_equal cursor3, connection.cursor_from_node(StarWars::Base.find(5))
+        assert_equal cursor4, connection.cursor_from_node(StarWars::Base.find(6))
+
+        connection = GraphQL::Relay::RelationConnection.new(StarWars::Base.offset(2), { first: 3, last: 1 })
+        assert_equal [StarWars::Base.find(5)], connection.edge_nodes
+
+        assert_equal cursor3, connection.cursor_from_node(StarWars::Base.find(5))
+
+        connection = GraphQL::Relay::RelationConnection.new(StarWars::Base.offset(2), { first: 2, last: 1 })
+        assert_equal [StarWars::Base.find(4)], connection.edge_nodes
+
+        assert_equal cursor2, connection.cursor_from_node(StarWars::Base.find(4))
+
+        connection = GraphQL::Relay::RelationConnection.new(StarWars::Base.offset(2), { after: cursor1 })
+        assert_equal [StarWars::Base.find(4), StarWars::Base.find(5), StarWars::Base.find(6)], connection.edge_nodes
+
+        assert_equal cursor2, connection.cursor_from_node(StarWars::Base.find(4))
+        assert_equal cursor3, connection.cursor_from_node(StarWars::Base.find(5))
+        assert_equal cursor4, connection.cursor_from_node(StarWars::Base.find(6))
+
+        connection = GraphQL::Relay::RelationConnection.new(StarWars::Base.offset(2), { after: cursor1, before: cursor1 })
+        assert_equal [], connection.edge_nodes
+
+        connection = GraphQL::Relay::RelationConnection.new(StarWars::Base.offset(2), { after: cursor1, before: cursor3 })
+        assert_equal [StarWars::Base.find(4)], connection.edge_nodes
+
+        assert_equal cursor2, connection.cursor_from_node(StarWars::Base.find(4))
+
+        connection = GraphQL::Relay::RelationConnection.new(StarWars::Base.offset(2), { after: cursor1, before: cursor4 })
+        assert_equal [StarWars::Base.find(4), StarWars::Base.find(5)], connection.edge_nodes
+
+        assert_equal cursor2, connection.cursor_from_node(StarWars::Base.find(4))
+        assert_equal cursor3, connection.cursor_from_node(StarWars::Base.find(5))
+
+
+        # Limit
+        connection = GraphQL::Relay::RelationConnection.new(StarWars::Base.limit(5), {})
+        assert_equal [StarWars::Base.find(1), StarWars::Base.find(2), StarWars::Base.find(3), StarWars::Base.find(4), StarWars::Base.find(5)], connection.edge_nodes
+
+        cursor1 = connection.cursor_from_node(StarWars::Base.find(1))
+        cursor2 = connection.cursor_from_node(StarWars::Base.find(2))
+        cursor3 = connection.cursor_from_node(StarWars::Base.find(3))
+        cursor4 = connection.cursor_from_node(StarWars::Base.find(4))
+
+        connection = GraphQL::Relay::RelationConnection.new(StarWars::Base.limit(5), { first: 2 })
+        assert_equal [StarWars::Base.find(1), StarWars::Base.find(2)], connection.edge_nodes
+
+        assert_equal cursor1, connection.cursor_from_node(StarWars::Base.find(1))
+        assert_equal cursor2, connection.cursor_from_node(StarWars::Base.find(2))
+
+        connection = GraphQL::Relay::RelationConnection.new(StarWars::Base.limit(5), { first: 2, last: 1 })
+        assert_equal [StarWars::Base.find(2)], connection.edge_nodes
+
+        assert_equal cursor2, connection.cursor_from_node(StarWars::Base.find(2))
+
+        connection = GraphQL::Relay::RelationConnection.new(StarWars::Base.limit(5), { after: cursor2, first: 2 })
+        assert_equal [StarWars::Base.find(3), StarWars::Base.find(4)], connection.edge_nodes
+
+        assert_equal cursor3, connection.cursor_from_node(StarWars::Base.find(3))
+        assert_equal cursor4, connection.cursor_from_node(StarWars::Base.find(4))
+
+        connection = GraphQL::Relay::RelationConnection.new(StarWars::Base.limit(5), { after: cursor2, first: 2, last: 1 })
+        assert_equal [StarWars::Base.find(4)], connection.edge_nodes
+
+        assert_equal cursor4, connection.cursor_from_node(StarWars::Base.find(4))
+
+        connection = GraphQL::Relay::RelationConnection.new(StarWars::Base.limit(5), { first: 2, last: 5 })
+        assert_equal [StarWars::Base.find(1), StarWars::Base.find(2)], connection.edge_nodes
+
+        assert_equal cursor1, connection.cursor_from_node(StarWars::Base.find(1))
+        assert_equal cursor2, connection.cursor_from_node(StarWars::Base.find(2))
+
+        connection = GraphQL::Relay::RelationConnection.new(StarWars::Base.limit(5), { first: 1, last: 5 })
+        assert_equal [StarWars::Base.find(1)], connection.edge_nodes
+
+        assert_equal cursor1, connection.cursor_from_node(StarWars::Base.find(1))
+
+        connection = GraphQL::Relay::RelationConnection.new(StarWars::Base.limit(5), { after: cursor1, before: cursor1 })
+        assert_equal [], connection.edge_nodes
+
+        connection = GraphQL::Relay::RelationConnection.new(StarWars::Base.limit(5), { after: cursor1, before: cursor3 })
+        assert_equal [StarWars::Base.find(2)], connection.edge_nodes
+
+        assert_equal cursor2, connection.cursor_from_node(StarWars::Base.find(2))
+
+        connection = GraphQL::Relay::RelationConnection.new(StarWars::Base.limit(5), { after: cursor1, before: cursor4 })
+        assert_equal [StarWars::Base.find(2), StarWars::Base.find(3)], connection.edge_nodes
+
+        assert_equal cursor2, connection.cursor_from_node(StarWars::Base.find(2))
+        assert_equal cursor3, connection.cursor_from_node(StarWars::Base.find(3))
+
+        connection = GraphQL::Relay::RelationConnection.new(StarWars::Base.limit(5), { last: 2, before: cursor4 })
+        assert_equal [StarWars::Base.find(2), StarWars::Base.find(3)], connection.edge_nodes
+
+        assert_equal cursor2, connection.cursor_from_node(StarWars::Base.find(2))
+        assert_equal cursor3, connection.cursor_from_node(StarWars::Base.find(3))
+
+
+        # Limit and offset
+        connection = GraphQL::Relay::RelationConnection.new(StarWars::Base.offset(2).limit(3), { first: 2 })
+        assert_equal [StarWars::Base.find(3), StarWars::Base.find(4)], connection.edge_nodes
+
+        connection = GraphQL::Relay::RelationConnection.new(StarWars::Base.offset(2).limit(3), { first: 2, last: 1 })
+        assert_equal [StarWars::Base.find(4)], connection.edge_nodes
+
+        connection = GraphQL::Relay::RelationConnection.new(StarWars::Base.offset(2).limit(3), { first: 2, last: 5 })
+        assert_equal [StarWars::Base.find(3), StarWars::Base.find(4)], connection.edge_nodes
+
+        connection = GraphQL::Relay::RelationConnection.new(StarWars::Base.offset(2).limit(3), { first: 1, last: 5 })
+        assert_equal [StarWars::Base.find(3)], connection.edge_nodes
+
+      end
+    end
+  end
 end

data/spec/graphql/schema/build_from_definition_spec.rb

@@ -701,6 +701,90 @@ SCHEMA
     end
   end
 
+  describe "executable schema with resolver maps" do
+    class Something
+      def capitalize(args)
+        args[:word].upcase
+      end
+    end
+
+    let(:definition) {
+      <<-GRAPHQL
+        scalar Date
+        scalar UndefinedScalar
+        type Something { capitalize(word:String!): String }
+        type A { a: String }
+        type B { b: String }
+        union Thing = A | B
+        type Query {
+          hello: Something
+          thing: Thing
+          add_week(in: Date!): Date!
+          undefined_scalar(str: String, int: Int): UndefinedScalar
+        }
+      GRAPHQL
+    }
+
+    let(:resolvers) {
+      {
+        Date: {
+          coerce_input: ->(val, ctx) {
+            Time.at(Float(val))
+          },
+          coerce_result: ->(val, ctx) {
+            val.to_f
+          }
+        },
+        resolve_type: ->(obj, ctx) {
+          return ctx.schema.types['A']
+        },
+        Query: {
+          add_week: ->(o,a,c) {
+            raise "No Time" unless a[:in].is_a? Time
+            a[:in]
+          },
+          hello: ->(o,a,c) {
+            Something.new
+          },
+          thing: ->(o,a,c) {
+            OpenStruct.new({a: "a"})
+          },
+          undefined_scalar: ->(o,a,c) {
+            a.values.first
+          }
+        }
+      }
+    }
+
+    let(:schema) { GraphQL::Schema.from_definition(definition, default_resolve: resolvers) }
+
+    it "resolves unions"  do
+      result = schema.execute("query { thing { ... on A { a } } }")
+      assert_equal(result.to_json,'{"data":{"thing":{"a":"a"}}}')
+    end
+
+    it "resolves scalars" do
+      result = schema.execute("query { add_week(in: 392277600.0) }")
+      assert_equal(result.to_json,'{"data":{"add_week":392277600.0}}')
+    end
+
+    it "passes args from graphql to the object"  do
+      result = schema.execute("query { hello { capitalize(word: \"hello\") }}")
+      assert_equal(result.to_json,'{"data":{"hello":{"capitalize":"HELLO"}}}')
+    end
+
+    it "handles undefined scalar resolution with identity function" do
+      result = schema.execute <<-GRAPHQL
+        {
+          str: undefined_scalar(str: "abc")
+          int: undefined_scalar(int: 123)
+        }
+      GRAPHQL
+
+      assert_equal({ "str" => "abc", "int" => 123 }, result["data"])
+    end
+  end
+
   describe "executable schemas from string" do
     let(:schema_defn) {
       <<-GRAPHQL
@@ -738,7 +822,7 @@ SCHEMA
       assert_equal(result.to_json, '{"data":{"allTodos":[{"text":"Pay the bills.","from_context":null},{"text":"Buy Milk","from_context":"bar"}]}}')
     end
 
-    describe "hash of resolvers" do
+    describe "hash of resolvers with defaults" do
       let(:todos) { [Todo.new("Pay the bills.")] }
       let(:schema) { GraphQL::Schema.from_definition(schema_defn, default_resolve: resolve_hash) }
       let(:resolve_hash) {
@@ -753,26 +837,16 @@ SCHEMA
         }
         h
       }
-      describe "with defaults" do
-        let(:base_hash) {
-          # Fallback is to resolve by sending the field name
-          Hash.new { |h, k| h[k] = Hash.new { |h2, k2| ->(obj, args, ctx) { obj.public_send(k2) } } }
-        }
 
-        it "accepts a hash of resolve functions" do
-          schema.execute("mutation { todoAdd: todo_add(text: \"Buy Milk\") { text } }", context: {context_value: "bar"}, root_value: todos)
-          result = schema.execute("query { allTodos: all_todos { text, from_context } }", root_value: todos)
-          assert_equal(result.to_json, '{"data":{"allTodos":[{"text":"Pay the bills.","from_context":null},{"text":"Buy Milk","from_context":"bar"}]}}')
-        end
-      end
+      let(:base_hash) {
+        # Fallback is to resolve by sending the field name
+        Hash.new { |h, k| h[k] = Hash.new { |h2, k2| ->(obj, args, ctx) { obj.public_send(k2) } } }
+      }
 
-      describe "wihtout defaults" do
-        let(:base_hash) { {} }
-        it "raises a KeyError" do
-          assert_raises(KeyError) do
-            schema.execute("mutation { todoAdd: todo_add(text: \"Buy Milk\") { text } }", context: {context_value: "bar"}, root_value: todos)
-          end
-        end
+      it "accepts a hash of resolve functions" do
+        schema.execute("mutation { todoAdd: todo_add(text: \"Buy Milk\") { text } }", context: {context_value: "bar"}, root_value: todos)
+        result = schema.execute("query { allTodos: all_todos { text, from_context } }", root_value: todos)
+        assert_equal(result.to_json, '{"data":{"allTodos":[{"text":"Pay the bills.","from_context":null},{"text":"Buy Milk","from_context":"bar"}]}}')
       end
     end
 

data/spec/graphql/schema/warden_spec.rb

@@ -103,11 +103,25 @@ module MaskHelpers
     end
   end
 
+  module FilterInstrumentation
+    def self.before_query(query)
+      if query.context[:filters]
+        query.merge_filters(
+          only: query.context[:filters][:only],
+          except: query.context[:filters][:except],
+        )
+      end
+    end
+
+    def self.after_query(q); end
+  end
+
   Schema = GraphQL::Schema.define do
     query QueryType
     mutation MutationType
     subscription MutationType
     resolve_type ->(obj, ctx) { PhonemeType }
+    instrument :query, FilterInstrumentation
   end
 
   module Data
@@ -591,4 +605,70 @@ describe GraphQL::Schema::Warden do
       refute_includes enum_values, "TRILL"
     end
   end
+
+  describe "multiple filters" do
+    let(:visible_enum_value) { ->(member, ctx) { !member.metadata[:hidden_enum_value] } }
+    let(:visible_abstract_type) { ->(member, ctx) { !member.metadata[:hidden_abstract_type] } }
+    let(:hidden_input_object) { ->(member, ctx) { member.metadata[:hidden_input_object_type] } }
+    let(:hidden_type) { ->(member, ctx) { member.metadata[:hidden_type] } }
+
+    let(:query_str) { <<-GRAPHQL
+      {
+        enum: __type(name: "Manner") { enumValues { name } }
+        input: __type(name: "WithinInput") { name }
+        abstractType: __type(name: "Grapheme") { interfaces { name } }
+        type: __type(name: "Phoneme") { name }
+      }
+    GRAPHQL
+    }
+
+    describe "multiple filters for execution" do
+      it "applies all of them" do
+        res = MaskHelpers.run_query(
+          query_str,
+          only: [visible_enum_value, visible_abstract_type],
+          except: [hidden_input_object, hidden_type],
+        )
+        assert_equal nil, res["data"]["input"]
+        enum_values = res["data"]["enum"]["enumValues"].map { |v| v["name"] }
+        assert_equal 5, enum_values.length
+        refute_includes enum_values, "TRILL"
+        # These are also filtered out:
+        assert_equal 0, res["data"]["abstractType"]["interfaces"].length
+        assert_equal nil, res["data"]["type"]
+      end
+    end
+
+    describe "adding filters in instrumentation" do
+      it "applies only/except filters" do
+        filters = {
+          only: visible_enum_value,
+          except: hidden_input_object,
+        }
+        res = MaskHelpers.run_query(query_str, context: { filters: filters })
+        assert_equal nil, res["data"]["input"]
+        enum_values = res["data"]["enum"]["enumValues"].map { |v| v["name"] }
+        assert_equal 5, enum_values.length
+        refute_includes enum_values, "TRILL"
+        # These are unaffected:
+        assert_includes res["data"]["abstractType"]["interfaces"].map { |i| i["name"] }, "LanguageMember"
+        assert_equal "Phoneme", res["data"]["type"]["name"]
+      end
+
+      it "applies multiple filters" do
+        filters = {
+          only: [visible_enum_value, visible_abstract_type],
+          except: [hidden_input_object, hidden_type],
+        }
+        res = MaskHelpers.run_query(query_str, context: { filters: filters })
+        assert_equal nil, res["data"]["input"]
+        enum_values = res["data"]["enum"]["enumValues"].map { |v| v["name"] }
+        assert_equal 5, enum_values.length
+        refute_includes enum_values, "TRILL"
+        # These are also filtered out:
+        assert_equal 0, res["data"]["abstractType"]["interfaces"].length
+        assert_equal nil, res["data"]["type"]
+      end
+    end
+  end
 end