graphql 1.6.8 → 1.7.0

data/spec/graphql/schema/build_from_definition_spec.rb

@@ -69,6 +69,8 @@ enum Color {
 
 # What a great type
 type Hello {
+  anEnum: Color
+
   # And a field to boot
   str: String
 }

data/spec/graphql/schema/traversal_spec.rb

@@ -2,10 +2,9 @@
 require "spec_helper"
 
 describe GraphQL::Schema::Traversal do
-  def reduce_types(types)
+  def traversal(types)
     schema = GraphQL::Schema.define(orphan_types: types, resolve_type: :dummy)
-    traversal = GraphQL::Schema::Traversal.new(schema, introspection: false)
-    traversal.type_map
+    GraphQL::Schema::Traversal.new(schema, introspection: false)
   end
 
   it "finds types from directives" do
@@ -13,7 +12,7 @@ describe GraphQL::Schema::Traversal do
       "Boolean" => GraphQL::BOOLEAN_TYPE, # `skip` argument
       "String" => GraphQL::STRING_TYPE # `deprecated` argument
     }
-    result = reduce_types([])
+    result = traversal([]).type_map
     assert_equal(expected.keys.sort, result.keys.sort)
     assert_equal(expected, result.to_h)
   end
@@ -31,13 +30,13 @@ describe GraphQL::Schema::Traversal do
       "AnimalProduct" => Dummy::AnimalProductInterface,
       "LocalProduct" => Dummy::LocalProductInterface,
     }
-    result = reduce_types([Dummy::CheeseType])
+    result = traversal([Dummy::CheeseType]).type_map
     assert_equal(expected.keys.sort, result.keys.sort)
     assert_equal(expected, result.to_h)
   end
 
   it "finds type from arguments" do
-    result = reduce_types([Dummy::DairyAppQueryType])
+    result = traversal([Dummy::DairyAppQueryType]).type_map
     assert_equal(Dummy::DairyProductInputType, result["DairyProductInput"])
   end
 
@@ -47,7 +46,7 @@ describe GraphQL::Schema::Traversal do
       connection :t, type.connection_type
     end
 
-    result = reduce_types([type])
+    result = traversal([type]).type_map
     expected_types = [
       "ArgTypeTest", "ArgTypeTestConnection", "ArgTypeTestEdge",
       "Boolean", "Int", "PageInfo", "String"
@@ -66,7 +65,7 @@ describe GraphQL::Schema::Traversal do
       input_field :child, type_child
     end
 
-    result = reduce_types([type_parent])
+    result = traversal([type_parent]).type_map
     expected = {
       "Boolean" => GraphQL::BOOLEAN_TYPE,
       "String" => GraphQL::STRING_TYPE,
@@ -92,11 +91,11 @@ describe GraphQL::Schema::Traversal do
     }
 
     it "raises an InvalidTypeError when passed nil" do
-      assert_raises(GraphQL::Schema::InvalidTypeError) {  reduce_types([invalid_type]) }
+      assert_raises(GraphQL::Schema::InvalidTypeError) {  traversal([invalid_type]) }
     end
 
     it "raises an InvalidTypeError when passed an object that isnt a GraphQL::BaseType" do
-      assert_raises(GraphQL::Schema::InvalidTypeError) {  reduce_types([another_invalid_type]) }
+      assert_raises(GraphQL::Schema::InvalidTypeError) {  traversal([another_invalid_type]) }
     end
   end
 
@@ -113,14 +112,14 @@ describe GraphQL::Schema::Traversal do
     }
     it "raises an error" do
       assert_raises(RuntimeError) {
-        reduce_types([type_1, type_2])
+        traversal([type_1, type_2])
       }
     end
   end
 
   describe "when getting a type which doesnt exist" do
     it "raises an error" do
-      type_map = reduce_types([])
+      type_map = traversal([]).type_map
       assert_raises(KeyError) { type_map.fetch("SomeType") }
     end
   end
@@ -130,4 +129,63 @@ describe GraphQL::Schema::Traversal do
       assert_equal Dummy::HoneyType, Dummy::Schema.types["Honey"]
     end
   end
+
+  it "finds all references to types from fields and arguments" do
+    c_type = GraphQL::InputObjectType.define do
+      name "C"
+      input_field :someField, GraphQL::STRING_TYPE
+    end
+
+    b_type = GraphQL::ObjectType.define do
+      name "B"
+      field :anotherField, !GraphQL::STRING_TYPE do |field|
+        field.argument :anArgument, c_type
+      end
+    end
+
+    a_type = GraphQL::ObjectType.define do
+      name "A"
+      field :someField, b_type
+    end
+
+    include_if_argument = GraphQL::Directive::IncludeDirective.arguments["if"]
+    skip_if_argument = GraphQL::Directive::SkipDirective.arguments["if"]
+    deprecated_reason_argument = GraphQL::Directive::DeprecatedDirective.arguments["reason"]
+
+    expected = {
+      "Boolean" => [include_if_argument, skip_if_argument],
+      "B" => [a_type.fields["someField"]],
+      "String" => [deprecated_reason_argument, b_type.fields["anotherField"], c_type.input_fields["someField"]],
+      "C" => [b_type.fields["anotherField"].arguments["anArgument"]]
+    }
+
+    assert_equal expected, traversal([a_type, b_type, c_type]).type_reference_map
+  end
+
+  it "finds unions from which types are members" do
+    b_type = GraphQL::ObjectType.define do
+      name "B"
+    end
+
+    c_type = GraphQL::ObjectType.define do
+      name "C"
+    end
+
+    union = GraphQL::UnionType.define do
+      name "AUnion"
+      possible_types [b_type]
+    end
+
+    another_union = GraphQL::UnionType.define do
+      name "AnotherUnion"
+      possible_types [b_type, c_type]
+    end
+
+    result = traversal([union, another_union, b_type, c_type]).union_memberships
+    expected = {
+      "B" => [union, another_union],
+      "C" => [another_union]
+    }
+    assert_equal expected, result
+  end
 end

data/spec/graphql/schema/warden_spec.rb

@@ -69,10 +69,29 @@ module MaskHelpers
     end
   end
 
+  CheremeInput = GraphQL::InputObjectType.define do
+    name "CheremeInput"
+    input_field :name, types.String
+  end
+
+  Chereme = GraphQL::ObjectType.define do
+    name "Chereme"
+    description "A basic unit of signed communication"
+    field :name, types.String.to_non_null_type
+  end
+
+  Character = GraphQL::ObjectType.define do
+    name "Character"
+    interfaces [LanguageMemberInterface]
+    field :code, types.Int
+  end
+
   QueryType = GraphQL::ObjectType.define do
     name "Query"
     field :languages, LanguageType.to_list_type do
-      argument :within, WithinInputType, "Find languages nearby a point"
+      argument :within, WithinInputType, "Find languages nearby a point" do
+        metadata :hidden_argument_with_input_object, true
+      end
     end
     field :language, LanguageType do
       metadata :hidden_field, true
@@ -81,6 +100,10 @@ module MaskHelpers
       end
     end
 
+    field :chereme, Chereme do
+      metadata :hidden_field, true
+    end
+
     field :phonemes, PhonemeType.to_list_type do
       argument :manners, MannerEnum.to_list_type, "Filter phonemes by manner of articulation"
     end
@@ -101,6 +124,12 @@ module MaskHelpers
     field :add_phoneme, PhonemeType do
       argument :symbol, types.String
     end
+
+    field :add_chereme, types.String do
+      argument :chereme, CheremeInput do
+        metadata :hidden_argument, true
+      end
+    end
   end
 
   module FilterInstrumentation
@@ -120,6 +149,7 @@ module MaskHelpers
     query QueryType
     mutation MutationType
     subscription MutationType
+    orphan_types [Character]
     resolve_type ->(type, obj, ctx) { PhonemeType }
     instrument :query, FilterInstrumentation
   end
@@ -225,6 +255,17 @@ describe GraphQL::Schema::Warden do
       ->(member, ctx) { member.metadata[:hidden_field] || member.metadata[:hidden_type] }
     }
 
+    it "hides types if no other fields are using it" do
+       query_string = %|
+         {
+           Chereme: __type(name: "Chereme") { fields { name } }
+         }
+       |
+
+       res = MaskHelpers.query_with_mask(query_string, mask)
+       assert_nil res["data"]["Chereme"]
+     end
+
     it "causes validation errors" do
       query_string = %|{ phoneme(symbol: "ϕ") { name } }|
       res = MaskHelpers.query_with_mask(query_string, mask)
@@ -370,6 +411,20 @@ describe GraphQL::Schema::Warden do
         interfaces_names = res["data"]["__type"]["interfaces"].map { |i| i["name"] }
         refute_includes interfaces_names, "LanguageMember"
       end
+
+      it "hides implementations if they are not referenced anywhere else" do
+        query_string = %|
+        {
+          __type(name: "Character") {
+            fields { name }
+          }
+        }
+        |
+
+        res = MaskHelpers.query_with_mask(query_string, mask)
+        type = res["data"]["__type"]
+        assert_equal nil, type
+      end
     end
   end
 
@@ -379,6 +434,17 @@ describe GraphQL::Schema::Warden do
       ->(member, ctx) { member.metadata[:hidden_argument] || member.metadata[:hidden_input_type] }
     }
 
+    it "hides types if no other fields or arguments are using it" do
+       query_string = %|
+         {
+           CheremeInput: __type(name: "CheremeInput") { fields { name } }
+         }
+       |
+
+       res = MaskHelpers.query_with_mask(query_string, mask)
+       assert_nil res["data"]["CheremeInput"]
+     end
+
     it "isn't present in introspection" do
       query_string = %|
       {

data/spec/graphql/schema_spec.rb

@@ -17,6 +17,35 @@ describe GraphQL::Schema do
     end
   end
 
+  describe "#union_memberships" do
+    it "returns a list of unions that include the type" do
+      assert_equal [schema.types["Animal"], schema.types["AnimalAsCow"]], schema.union_memberships(schema.types["Cow"])
+    end
+  end
+
+  describe "#root_types" do
+    it "returns a list of the schema's root types" do
+      assert_equal(
+        [
+          Dummy::DairyAppQueryType,
+          Dummy::DairyAppMutationType,
+          Dummy::SubscriptionType
+        ],
+        schema.root_types
+      )
+    end
+  end
+
+  describe "#references_to" do
+    it "returns a list of Field and Arguments of that type" do
+      assert_equal [schema.types["Query"].fields["cow"]], schema.references_to("Cow")
+    end
+
+    it "returns an empty list when type is not referenced by any field or argument" do
+      assert_equal [], schema.references_to("Goat")
+    end
+  end
+
   describe "#to_definition" do
     it "prints out the schema definition" do
       assert_equal schema.to_definition, GraphQL::Schema::Printer.print_schema(schema)

data/spec/graphql/static_validation/validator_spec.rb

@@ -7,6 +7,22 @@ describe GraphQL::StaticValidation::Validator do
   let(:validate) { true }
   let(:errors) { validator.validate(query, validate: validate)[:errors].map(&:to_h) }
 
+  describe "tracing" do
+    let(:query_string) { "{ t: __typename }"}
+
+    it "emits a trace" do
+      traces = TestTracing.with_trace do
+        validator.validate(query)
+      end
+
+      assert_equal 3, traces.length
+      _lex_trace, _parse_trace, validate_trace = traces
+      assert_equal "validate", validate_trace[:key]
+      assert_equal true, validate_trace[:validate]
+      assert_instance_of GraphQL::Query, validate_trace[:query]
+      assert_instance_of Hash, validate_trace[:result]
+    end
+  end
 
   describe "validation order" do
     let(:document) { GraphQL.parse(query_string)}

data/spec/graphql/subscriptions_spec.rb

@@ -0,0 +1,331 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+class InMemoryBackend
+  class Subscriptions < GraphQL::Subscriptions
+    attr_reader :deliveries, :pushes, :extra
+
+    def initialize(schema:, extra:)
+      super
+      @extra = extra
+      @queries = {}
+      @subscriptions = Hash.new { |h, k| h[k] = [] }
+      @deliveries = Hash.new { |h, k| h[k] = [] }
+      @pushes = []
+    end
+
+    def write_subscription(query, events)
+      @queries[query.context[:socket]] = query
+      events.each do |ev|
+        # The `context` is functioning as subscription data.
+        # IRL you'd have some other model that persisted the subscription
+        @subscriptions[ev.topic] << ev.context
+      end
+    end
+
+    def each_subscription_id(event)
+      @subscriptions[event.topic].each do |ctx|
+        yield(ctx[:socket])
+      end
+    end
+
+    def read_subscription(channel)
+      query = @queries[channel]
+      {
+        query_string: query.query_string,
+        operation_name: query.operation_name,
+        variables: query.provided_variables,
+        context: { me: query.context[:me] },
+        transport: :socket,
+      }
+    end
+
+    def delete_subscription(channel)
+      query = @queries.delete(channel)
+      if query
+        @subscriptions.each do |key, contexts|
+          contexts.delete(query.context)
+        end
+      end
+    end
+
+    def deliver(channel, result)
+      @deliveries[channel] << result
+    end
+
+    def execute(channel, event, object)
+      @pushes << channel
+      super
+    end
+
+    # Just for testing:
+    def reset
+      @queries.clear
+      @subscriptions.clear
+      @deliveries.clear
+      @pushes.clear
+    end
+
+    def size
+      @subscriptions.size
+    end
+
+    def subscriptions
+      @subscriptions
+    end
+  end
+  # Just a random stateful object for tracking what happens:
+  class Payload
+    attr_reader :str
+
+    def initialize
+      @str = "Update"
+      @counter = 0
+    end
+
+    def int
+      @counter += 1
+    end
+  end
+
+  SchemaDefinition = <<-GRAPHQL
+  type Subscription {
+    payload(id: ID!): Payload!
+    event(stream: StreamInput): Payload
+    myEvent(type: PayloadType): Payload
+  }
+
+  type Payload {
+    str: String!
+    int: Int!
+  }
+
+  input StreamInput {
+    userId: ID!
+    type: PayloadType = ONE
+  }
+
+  # Arbitrary "kinds" of payloads which may be
+  # subscribed to separately
+  enum PayloadType {
+    ONE
+    TWO
+  }
+
+  type Query {
+    dummy: Int
+  }
+  GRAPHQL
+
+  Resolvers = {
+    "Subscription" => {
+      "payload" => ->(o,a,c) { o },
+      "myEvent" => ->(o,a,c) { o },
+      "event" => ->(o,a,c) { o },
+    },
+  }
+  Schema = GraphQL::Schema.from_definition(SchemaDefinition, default_resolve: Resolvers).redefine do
+    use InMemoryBackend::Subscriptions,
+      extra: 123
+  end
+
+  # TODO don't hack this (no way to add metadata from IDL parser right now)
+  Schema.get_field("Subscription", "myEvent").subscription_scope = :me
+end
+
+describe GraphQL::Subscriptions do
+  before do
+    schema.subscriptions.reset
+  end
+
+  let(:root_object) {
+    OpenStruct.new(
+      payload: InMemoryBackend::Payload.new,
+    )
+  }
+
+  let(:schema) { InMemoryBackend::Schema }
+  let(:implementation) { schema.subscriptions }
+  let(:deliveries) { implementation.deliveries }
+  describe "pushing updates" do
+    it "sends updated data" do
+      query_str = <<-GRAPHQL
+        subscription ($id: ID!){
+          firstPayload: payload(id: $id) { str, int }
+          otherPayload: payload(id: "900") { int }
+        }
+      GRAPHQL
+
+      # Initial subscriptions
+      res_1 = schema.execute(query_str, context: { socket: "1" }, variables: { "id" => "100" }, root_value: root_object)
+      res_2 = schema.execute(query_str, context: { socket: "2" }, variables: { "id" => "200" }, root_value: root_object)
+
+      # Initial response is nil, no broadcasts yet
+      assert_equal(nil, res_1["data"])
+      assert_equal(nil, res_2["data"])
+      assert_equal [], deliveries["1"]
+      assert_equal [], deliveries["2"]
+
+      # Application stuff happens.
+      # The application signals graphql via `subscriptions.trigger`:
+      schema.subscriptions.trigger("payload", {"id" => "100"}, root_object.payload)
+      schema.subscriptions.trigger("payload", {"id" => "200"}, root_object.payload)
+      schema.subscriptions.trigger("payload", {"id" => "100"}, root_object.payload)
+      schema.subscriptions.trigger("payload", {"id" => "300"}, nil)
+
+      # Let's see what GraphQL sent over the wire:
+      assert_equal({"str" => "Update", "int" => 1}, deliveries["1"][0]["data"]["firstPayload"])
+      assert_equal({"str" => "Update", "int" => 2}, deliveries["2"][0]["data"]["firstPayload"])
+      assert_equal({"str" => "Update", "int" => 3}, deliveries["1"][1]["data"]["firstPayload"])
+    end
+  end
+
+  describe "subscribing" do
+    it "doesn't call the subscriptions for invalid queries" do
+      query_str = <<-GRAPHQL
+        subscription ($id: ID){
+          payload(id: $id) { str, int }
+        }
+      GRAPHQL
+
+      res = schema.execute(query_str, context: { socket: "1" }, variables: { "id" => "100" }, root_value: root_object)
+      assert_equal true, res.key?("errors")
+      assert_equal 0, implementation.size
+    end
+  end
+
+  describe "trigger" do
+    it "uses the provided queue" do
+      query_str = <<-GRAPHQL
+        subscription ($id: ID!){
+          payload(id: $id) { str, int }
+        }
+      GRAPHQL
+
+      schema.execute(query_str, context: { socket: "1" }, variables: { "id" => "8" }, root_value: root_object)
+      schema.subscriptions.trigger("payload", { "id" => "8"}, root_object.payload)
+      assert_equal ["1"], implementation.pushes
+    end
+
+    it "pushes errors" do
+      query_str = <<-GRAPHQL
+        subscription ($id: ID!){
+          payload(id: $id) { str, int }
+        }
+      GRAPHQL
+
+      schema.execute(query_str, context: { socket: "1" }, variables: { "id" => "8" }, root_value: root_object)
+      schema.subscriptions.trigger("payload", { "id" => "8"}, OpenStruct.new(str: nil, int: nil))
+      delivery = deliveries["1"].first
+      assert_equal nil, delivery.fetch("data")
+      assert_equal 1, delivery["errors"].length
+    end
+
+    it "coerces args" do
+      query_str = <<-GRAPHQL
+        subscription($type: PayloadType) {
+          e1: event(stream: { userId: "3", type: $type }) { int }
+        }
+      GRAPHQL
+
+      # Subscribe with explicit `TYPE`
+      schema.execute(query_str, context: { socket: "1" }, variables: { "type" => "ONE" }, root_value: root_object)
+      # Subscribe with default `TYPE`
+      schema.execute(query_str, context: { socket: "2" }, root_value: root_object)
+      # Subscribe with non-matching `TYPE`
+      schema.execute(query_str, context: { socket: "3" }, variables: { "type" => "TWO" }, root_value: root_object)
+      # Subscribe with explicit null
+      schema.execute(query_str, context: { socket: "4" }, variables: { "type" => nil }, root_value: root_object)
+
+      # Trigger the subscription with coerceable args, different orders:
+      schema.subscriptions.trigger("event", { "stream" => {"userId" => 3, "type" => "ONE"} }, OpenStruct.new(str: "", int: 1))
+      schema.subscriptions.trigger("event", { "stream" => {"type" => "ONE", "userId" => "3"} }, OpenStruct.new(str: "", int: 2))
+      # This is a non-trigger
+      schema.subscriptions.trigger("event", { "stream" => {"userId" => "3", "type" => "TWO"} }, OpenStruct.new(str: "", int: 3))
+      # These get default value of ONE
+      schema.subscriptions.trigger("event", { "stream" => {"userId" => "3"} }, OpenStruct.new(str: "", int: 4))
+      # Trigger with null updates subscriptionss to null
+      schema.subscriptions.trigger("event", { "stream" => {"userId" => 3, "type" => nil} }, OpenStruct.new(str: "", int: 5))
+
+      assert_equal [1,2,4], deliveries["1"].map { |d| d["data"]["e1"]["int"] }
+
+      # Same as socket_1
+      assert_equal [1,2,4], deliveries["2"].map { |d| d["data"]["e1"]["int"] }
+
+      # Received the "non-trigger"
+      assert_equal [3], deliveries["3"].map { |d| d["data"]["e1"]["int"] }
+
+      # Received the trigger with null
+      assert_equal [5], deliveries["4"].map { |d| d["data"]["e1"]["int"] }
+    end
+
+    it "allows context-scoped subscriptions" do
+      query_str = <<-GRAPHQL
+        subscription($type: PayloadType) {
+          myEvent(type: $type) { int }
+        }
+      GRAPHQL
+
+      # Subscriptions for user 1
+      schema.execute(query_str, context: { socket: "1", me: "1" }, variables: { "type" => "ONE" }, root_value: root_object)
+      schema.execute(query_str, context: { socket: "2", me: "1" }, variables: { "type" => "TWO" }, root_value: root_object)
+      # Subscription for user 2
+      schema.execute(query_str, context: { socket: "3", me: "2" }, variables: { "type" => "ONE" }, root_value: root_object)
+
+      schema.subscriptions.trigger("myEvent", { "type" => "ONE" }, OpenStruct.new(str: "", int: 1), scope: "1")
+      schema.subscriptions.trigger("myEvent", { "type" => "TWO" }, OpenStruct.new(str: "", int: 2), scope: "1")
+      schema.subscriptions.trigger("myEvent", { "type" => "ONE" }, OpenStruct.new(str: "", int: 3), scope: "2")
+
+      # Delivered to user 1
+      assert_equal [1], deliveries["1"].map { |d| d["data"]["myEvent"]["int"] }
+      assert_equal [2], deliveries["2"].map { |d| d["data"]["myEvent"]["int"] }
+      # Delivered to user 2
+      assert_equal [3], deliveries["3"].map { |d| d["data"]["myEvent"]["int"] }
+    end
+
+    describe "errors" do
+      class ErrorPayload
+        def int
+          raise "Boom!"
+        end
+
+        def str
+          raise GraphQL::ExecutionError.new("This is handled")
+        end
+      end
+
+      it "lets unhandled errors crash "do
+        query_str = <<-GRAPHQL
+          subscription($type: PayloadType) {
+            myEvent(type: $type) { int }
+          }
+        GRAPHQL
+
+        schema.execute(query_str, context: { socket: "1", me: "1" }, variables: { "type" => "ONE" }, root_value: root_object)
+        err = assert_raises(RuntimeError) {
+          schema.subscriptions.trigger("myEvent", { "type" => "ONE" }, ErrorPayload.new, scope: "1")
+        }
+        assert_equal "Boom!", err.message
+      end
+    end
+
+    it "sends query errors to the subscriptions" do
+      query_str = <<-GRAPHQL
+        subscription($type: PayloadType) {
+          myEvent(type: $type) { str }
+        }
+      GRAPHQL
+
+      schema.execute(query_str, context: { socket: "1", me: "1" }, variables: { "type" => "ONE" }, root_value: root_object)
+      schema.subscriptions.trigger("myEvent", { "type" => "ONE" }, ErrorPayload.new, scope: "1")
+      res = deliveries["1"].first
+      assert_equal "This is handled", res["errors"][0]["message"]
+    end
+  end
+
+  describe "implementation" do
+    it "is initialized with keywords" do
+      assert_equal 123, schema.subscriptions.extra
+    end
+  end
+end