graphql 1.5.7.1 → 1.5.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1d62327a63cfe014162e4914f6667336e606e8ff
-  data.tar.gz: 2605ce8d9b8c31b29ad2c539f4da250e02450f66
+  metadata.gz: 96bef39c8a37b049f8843e78d2f15f1c10430d16
+  data.tar.gz: 23c0c140f6e0bba9fc17468b702102d61cd48044
 SHA512:
-  metadata.gz: dc114df5775f181f92b11aff4c4eaf022506b994d69889fd88643fa7f0b03348ffaddfe7e2851032a6a384259629d5484dfbabb9b7e7185875336390066037f4
-  data.tar.gz: 490d0958520560087668555b95e91d4188a068a32ab87f9d02d21924da843b9108da9cac3d558b36314705344737a4271a537ce66535f441030a240a6e02747a
+  metadata.gz: f5e3451aa0669e2896255851dcfdae11fae11e190db815d2b322076915633f482eef27749374cdab094fdd456ba6420afce12b075f25a71aa709da57374184f3
+  data.tar.gz: 442f220e5edf3087e9bc4fed9fa263096a551c66d88d01f03d58fe431eee72a7fb9067a54569d4f33768a2ebb274f8ec91e4492223281febe29eb12164039c87

data/lib/graphql/compatibility/lazy_execution_specification.rb

@@ -167,6 +167,7 @@ module GraphQL
               "PUSH",
               "Query.push: 1",
               "Query.push: 2",
+              "Query.pushes: [1, 2, 3]",
               "PUSH",
               "LazyPush.push: 3",
               "LazyPushEdge.node: 1",

data/lib/graphql/compatibility/lazy_execution_specification/lazy_schema.rb

@@ -37,6 +37,10 @@ module GraphQL
           def push
             @values.map { |v| LazyPush.new(@ctx, v) }
           end
+
+          def value
+            @values
+          end
         end
 
         module LazyInstrumentation

data/lib/graphql/define/assign_connection.rb

@@ -4,8 +4,9 @@ module GraphQL
     module AssignConnection
       def self.call(type_defn, *field_args, max_page_size: nil, **field_kwargs, &field_block)
         underlying_field = GraphQL::Define::AssignObjectField.call(type_defn, *field_args, **field_kwargs, &field_block)
-        connection_field = GraphQL::Relay::ConnectionField.create(underlying_field, max_page_size: max_page_size)
-        type_defn.fields[underlying_field.name] = connection_field
+        underlying_field.connection_max_page_size = max_page_size
+        underlying_field.connection = true
+        type_defn.fields[underlying_field.name] = underlying_field
       end
     end
   end

data/lib/graphql/execution/typecast.rb

@@ -28,8 +28,8 @@ module GraphQL
               false
             end
           when GraphQL::UnionType
-            # A type is a subtype of that interface
-            # if the union includes that interface
+            # A type is a subtype of that union
+            # if the union includes that type
             parent_type.possible_types.include?(child_type)
           when GraphQL::ListType
             # A list type is a subtype of another list type

data/lib/graphql/field.rb

@@ -177,6 +177,16 @@ module GraphQL
     # @return [Object, GraphQL::Function] The function used to derive this field
     attr_accessor :function
 
+    attr_writer :connection
+
+    # @return [Boolean]
+    def connection?
+      @connection
+    end
+
+    # @return [nil, Integer]
+    attr_accessor :connection_max_page_size
+
     def initialize
       @complexity = 1
       @arguments = {}
@@ -184,6 +194,8 @@ module GraphQL
       @lazy_resolve_proc = DefaultLazyResolve
       @relay_node_field = false
       @default_arguments = nil
+      @connection = false
+      @connection_max_page_size = nil
     end
 
     def initialize_copy(other)

data/lib/graphql/internal_representation.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 require "graphql/internal_representation/node"
+require "graphql/internal_representation/print"
 require "graphql/internal_representation/rewrite"
 require "graphql/internal_representation/scope"
 require "graphql/internal_representation/visit"

data/lib/graphql/internal_representation/node.rb

@@ -19,6 +19,9 @@ module GraphQL
           if @scoped_children.any?
             all_object_types = Set.new
             scoped_children.each_key { |t| all_object_types.merge(@query.possible_types(t)) }
+            # Remove any scoped children which don't follow this return type
+            # (This can happen with fragment merging where lexical scope is lost)
+            all_object_types &= @query.possible_types(@return_type)
             all_object_types.each do |t|
               new_tc[t] = get_typed_children(t)
             end
@@ -111,19 +114,23 @@ module GraphQL
 
       # Merge selections from `new_parent` into `self`.
       # Selections are merged in place, not copied.
-      def deep_merge_node(new_parent, merge_self: true)
+      def deep_merge_node(new_parent, scope: nil, merge_self: true)
         if merge_self
-          @ast_nodes |= new_parent.ast_nodes
-          @definitions |= new_parent.definitions
+          @ast_nodes.concat(new_parent.ast_nodes)
+          @definitions.concat(new_parent.definitions)
         end
+        scope ||= Scope.new(@query, @return_type)
         new_parent.scoped_children.each do |obj_type, new_fields|
-          prev_fields = @scoped_children[obj_type]
-          new_fields.each do |name, new_node|
-            prev_node = prev_fields[name]
-            if prev_node
-              prev_node.deep_merge_node(new_node)
-            else
-              prev_fields[name] = new_node
+          inner_scope = scope.enter(obj_type)
+          inner_scope.each do |scoped_type|
+            prev_fields = @scoped_children[scoped_type]
+            new_fields.each do |name, new_node|
+              prev_node = prev_fields[name]
+              if prev_node
+                prev_node.deep_merge_node(new_node)
+              else
+                prev_fields[name] = new_node
+              end
             end
           end
         end

data/lib/graphql/internal_representation/print.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+module GraphQL
+  module InternalRepresentation
+    module Print
+      module_function
+
+      def print(schema, query_string)
+        query = GraphQL::Query.new(schema, query_string)
+        print_node(query.irep_selection)
+      end
+
+      def print_node(node, indent: 0)
+        padding = " " * indent
+        typed_children_padding = " " * (indent + 2)
+        query_str = "".dup
+
+        if !node.definition
+          op_node = node.ast_node
+          name = op_node.name ? " " + op_node.name : ""
+          op_type = op_node.operation_type
+          query_str << "#{op_type}#{name}"
+        else
+          if node.name == node.definition_name
+            query_str << "#{padding}#{node.name}"
+          else
+            query_str << "#{padding}#{node.name}: #{node.definition_name}"
+          end
+
+          args = node.ast_nodes.map { |n| n.arguments.map(&:to_query_string).join(",") }.uniq
+          query_str << args.map { |a| "(#{a})"}.join("|")
+        end
+
+        if node.typed_children.any?
+          query_str << " {\n"
+          node.typed_children.each do |type, children|
+            query_str << "#{typed_children_padding}... on #{type.name} {\n"
+            children.each do |name, child|
+              query_str << print_node(child, indent: indent + 4)
+            end
+            query_str << "#{typed_children_padding}}\n"
+          end
+          query_str << "#{padding}}\n"
+        else
+          query_str << "\n"
+        end
+
+        query_str
+      end
+    end
+  end
+end

data/lib/graphql/internal_representation/rewrite.rb

@@ -31,6 +31,8 @@ module GraphQL
         # Hash<Nodes::FragmentSpread => Set<InternalRepresentation::Node>>
         # A record of fragment spreads and the irep nodes that used them
         spread_parents = Hash.new { |h, k| h[k] = Set.new }
+        # Hash<Nodes::FragmentSpread => Scope>
+        spread_scopes = {}
         # Array<Set<InternalRepresentation::Node>>
         # The current point of the irep_tree during visitation
         nodes_stack = []
@@ -124,6 +126,7 @@ module GraphQL
           if skip_nodes.none? && !skip?(ast_node, query)
             # Register the irep nodes that depend on this AST node:
             spread_parents[ast_node].merge(nodes_stack.last)
+            spread_scopes[ast_node] = scopes_stack.last
           end
         }
 
@@ -139,8 +142,9 @@ module GraphQL
           if fragment_node
             spread_ast_nodes.each do |spread_ast_node|
               parent_nodes = spread_parents[spread_ast_node]
+              parent_scope = spread_scopes[spread_ast_node]
               parent_nodes.each do |parent_node|
-                parent_node.deep_merge_node(fragment_node, merge_self: false)
+                parent_node.deep_merge_node(fragment_node, scope: parent_scope, merge_self: false)
               end
             end
           end

data/lib/graphql/relay.rb

@@ -11,6 +11,6 @@ require 'graphql/relay/relation_connection'
 require 'graphql/relay/global_id_resolve'
 require 'graphql/relay/mutation'
 require 'graphql/relay/node'
-require 'graphql/relay/connection_field'
+require 'graphql/relay/connection_instrumentation'
 require 'graphql/relay/connection_resolve'
 require 'graphql/relay/connection_type'

data/lib/graphql/relay/{connection_field.rb → connection_instrumentation.rb}

@@ -2,12 +2,11 @@
 module GraphQL
   module Relay
     # Provided a GraphQL field which returns a collection of nodes,
-    # `ConnectionField.create` modifies that field to expose those nodes
-    # as a collection.
+    # wrap that field to expose those nodes as a connection.
     #
     # The original resolve proc is used to fetch nodes,
     # then a connection implementation is fetched with {BaseConnection.connection_for_nodes}.
-    class ConnectionField
+    module ConnectionInstrumentation
       ARGUMENT_DEFINITIONS = [
           ["first", GraphQL::INT_TYPE, "Returns the first _n_ elements from the list."],
           ["after", GraphQL::STRING_TYPE, "Returns the elements in the list that come after the specified global ID."],
@@ -28,14 +27,21 @@ module GraphQL
       # Build a connection field from a {GraphQL::Field} by:
       # - Merging in the default arguments
       # - Transforming its resolve function to return a connection object
-      # @param underlying_field [GraphQL::Field] A field which returns nodes to be wrapped as a connection
-      # @param max_page_size [Integer] The maximum number of nodes which may be requested (if a larger page is requested, it is limited to this number)
-      # @return [GraphQL::Field] A redefined field with connection behavior
-      def self.create(underlying_field, max_page_size: nil)
-        connection_arguments = DEFAULT_ARGUMENTS.merge(underlying_field.arguments)
-        original_resolve = underlying_field.resolve_proc
-        connection_resolve = GraphQL::Relay::ConnectionResolve.new(underlying_field, original_resolve, max_page_size: max_page_size)
-        underlying_field.redefine(resolve: connection_resolve, arguments: connection_arguments)
+      def self.instrument(type, field)
+        if field.connection?
+          connection_arguments = DEFAULT_ARGUMENTS.merge(field.arguments)
+          original_resolve = field.resolve_proc
+          original_lazy_resolve = field.lazy_resolve_proc
+          connection_resolve = GraphQL::Relay::ConnectionResolve.new(field, original_resolve)
+          connection_lazy_resolve = GraphQL::Relay::ConnectionResolve.new(field, original_lazy_resolve)
+          field.redefine(
+            resolve: connection_resolve,
+            lazy_resolve: connection_lazy_resolve,
+            arguments: connection_arguments,
+          )
+        else
+          field
+        end
       end
     end
   end

data/lib/graphql/relay/connection_resolve.rb

@@ -2,18 +2,16 @@
 module GraphQL
   module Relay
     class ConnectionResolve
-      def initialize(field, underlying_resolve, max_page_size: nil)
+      def initialize(field, underlying_resolve)
         @field = field
         @underlying_resolve = underlying_resolve
-        @max_page_size = max_page_size
+        @max_page_size = field.connection_max_page_size
       end
 
       def call(obj, args, ctx)
         nodes = @underlying_resolve.call(obj, args, ctx)
         if ctx.schema.lazy?(nodes)
-          @field.prepare_lazy(nodes, args, ctx).then { |resolved_nodes|
-            build_connection(resolved_nodes, args, obj, ctx)
-          }
+          nodes
         else
           build_connection(nodes, args, obj, ctx)
         end

data/lib/graphql/relay/mutation.rb

@@ -122,7 +122,7 @@ module GraphQL
       end
 
       def resolve=(new_resolve_proc)
-        @resolve_proc = MutationResolve.new(self, new_resolve_proc, wrap_result: has_generated_return_type?)
+        @resolve_proc = new_resolve_proc
       end
 
       def field
@@ -218,20 +218,34 @@ module GraphQL
         end
       end
 
+      module MutationInstrumentation
+        def self.instrument(type, field)
+          if field.mutation
+            new_resolve = MutationResolve.new(field.mutation, field.resolve_proc)
+            new_lazy_resolve = MutationResolve.new(field.mutation, field.lazy_resolve_proc)
+            field.redefine(resolve: new_resolve, lazy_resolve: new_lazy_resolve)
+          else
+            field
+          end
+        end
+      end
+
       class MutationResolve
-        def initialize(mutation, resolve, wrap_result:)
+        def initialize(mutation, resolve)
           @mutation = mutation
           @resolve = resolve
-          @wrap_result = wrap_result
+          @wrap_result = mutation.has_generated_return_type?
         end
 
         def call(obj, args, ctx)
-          mutation_result = @resolve.call(obj, args[:input], ctx)
+          begin
+            mutation_result = @resolve.call(obj, args[:input], ctx)
+          rescue GraphQL::ExecutionError => err
+            mutation_result = err
+          end
 
           if ctx.schema.lazy?(mutation_result)
-            @mutation.field.prepare_lazy(mutation_result, args, ctx).then { |inner_obj|
-              build_result(inner_obj, args, ctx)
-            }
+            mutation_result
           else
             build_result(mutation_result, args, ctx)
           end

data/lib/graphql/relay/page_info.rb

@@ -5,10 +5,10 @@ module GraphQL
     PageInfo = GraphQL::ObjectType.define do
       name("PageInfo")
       description("Information about pagination in a connection.")
-      field :hasNextPage, !types.Boolean, "Indicates if there are more pages to fetch", property: :has_next_page
-      field :hasPreviousPage, !types.Boolean, "Indicates if there are any pages prior to the current page", property: :has_previous_page
-      field :startCursor, types.String, "When paginating backwards, the cursor to continue", property: :start_cursor
-      field :endCursor, types.String, "When paginating forwards, the cursor to continue", property: :end_cursor
+      field :hasNextPage, !types.Boolean, "When paginating forwards, are there more items?", property: :has_next_page
+      field :hasPreviousPage, !types.Boolean, "When paginating backwards, are there more items?", property: :has_previous_page
+      field :startCursor, types.String, "When paginating backwards, the cursor to continue.", property: :start_cursor
+      field :endCursor, types.String, "When paginating forwards, the cursor to continue.", property: :end_cursor
       default_relay true
     end
   end

data/lib/graphql/schema.rb

@@ -433,8 +433,15 @@ module GraphQL
 
     private
 
+    # Apply instrumentation to fields. Relay instrumentation is applied last
+    # so that user-provided instrumentation can wrap user-provided resolve functions,
+    # _then_ Relay helpers can wrap the returned objects.
     def build_instrumented_field_map
-      @instrumented_field_map = InstrumentedFieldMap.new(self, @instrumenters[:field])
+      all_instrumenters = @instrumenters[:field] + [
+        GraphQL::Relay::ConnectionInstrumentation,
+        GraphQL::Relay::Mutation::MutationInstrumentation,
+      ]
+      @instrumented_field_map = InstrumentedFieldMap.new(self, all_instrumenters)
     end
 
     def build_types_map

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.5.7.1"
+  VERSION = "1.5.8"
 end

data/spec/graphql/internal_representation/print_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::InternalRepresentation::Print do
+  describe "printing queries" do
+    let(:query_str) { <<-GRAPHQL
+    {
+      cheese(id: 1) {
+        flavor
+        ...EdibleFields
+        ... on Edible {
+          o2: origin
+        }
+      }
+    }
+
+    fragment EdibleFields on Edible {
+      o: origin
+    }
+    GRAPHQL
+  }
+    it "prints the rewritten query" do
+      query_plan = GraphQL::InternalRepresentation::Print.print(Dummy::Schema, query_str)
+      expected_plan = <<-GRAPHQL
+query {
+  ... on Query {
+    cheese(id: 1) {
+      ... on Cheese {
+        flavor()
+        o2: origin()
+        o: origin()
+      }
+    }
+  }
+}
+      GRAPHQL
+
+      assert_equal expected_plan, query_plan
+    end
+  end
+end

data/spec/graphql/internal_representation/rewrite_spec.rb

@@ -6,7 +6,6 @@ describe GraphQL::InternalRepresentation::Rewrite do
     GraphQL::Schema.from_definition <<-GRAPHQL
     type Query {
       plant(id: ID!): Plant
-      fruit(id: ID!): [Fruit!]
     }
 
     union Plant = Grain | Fruit | Vegetable | Nut
@@ -45,11 +44,7 @@ describe GraphQL::InternalRepresentation::Rewrite do
       habitats: [Habitat]
     }
 
-    interface Environ {
-      seasons: [String]
-    }
-
-    type Habitat implements Environ {
+    type Habitat {
       residentName: String!
       averageWeight: Int!
       seasons: [String]
@@ -113,7 +108,7 @@ describe GraphQL::InternalRepresentation::Rewrite do
       assert_equal nil, doc.definition
 
       plant_scoped_selection = doc.scoped_children[schema.types["Query"]]["plant"]
-      assert_equal ["Fruit", "Nut", "Plant", "Tree"], plant_scoped_selection.scoped_children.keys.map(&:name).sort
+      assert_equal ["Fruit", "Nut", "Plant"], plant_scoped_selection.scoped_children.keys.map(&:name).sort
 
       plant_selection = doc.typed_children[schema.types["Query"]]["plant"]
       assert_equal ["Fruit", "Grain", "Nut", "Vegetable"], plant_selection.typed_children.keys.map(&:name).sort
@@ -291,36 +286,4 @@ describe GraphQL::InternalRepresentation::Rewrite do
       end
     end
   end
-
-  describe "fragment merging bug" do
-    let(:query_string) {
-      <<-GRAPHQL
-      {
-        ...Frag1
-        __type(name: "Query") {
-          ...Frag2
-        }
-      }
-
-      fragment Frag1 on Query {
-        __type(name: "Query") {
-          ...Frag2
-        }
-      }
-
-      fragment Frag2 on __Type {
-        __typename
-      }
-      GRAPHQL
-    }
-
-    it "finishes" do
-      doc = rewrite_result[nil]
-      type_node = doc.typed_children[schema.types["Query"]]["__type"]
-      typename_node = type_node.typed_children[schema.types["__Type"]]["__typename"]
-      assert_equal 1, typename_node.ast_nodes.size
-      assert_equal 15, typename_node.ast_node.line
-      assert_equal 9, typename_node.ast_node.col
-    end
-  end
 end

data/spec/graphql/relay/{connection_field_spec.rb → connection_instrumentation_spec.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 require "spec_helper"
 
-describe GraphQL::Relay::ConnectionField do
+describe GraphQL::Relay::ConnectionInstrumentation do
   it "replaces the previous field definition" do
     test_type = GraphQL::ObjectType.define do
       name "Test"
@@ -16,7 +16,7 @@ describe GraphQL::Relay::ConnectionField do
     assert_instance_of StarWars::ShipsWithMaxPageSize, conn_field.function
   end
 
-  it "leaves the original field untouched" do
+  let(:build_schema) {
     test_type = nil
 
     test_field = GraphQL::Field.define do
@@ -29,7 +29,15 @@ describe GraphQL::Relay::ConnectionField do
       connection :tests, test_field
     end
 
-    conn_field = test_type.fields["tests"]
+    [
+      test_field,
+      GraphQL::Schema.define(query: test_type, raise_definition_error: true)
+    ]
+  }
+
+  it "leaves the original field untouched" do
+    test_field, test_schema = build_schema
+    conn_field = test_schema.get_field(test_schema.query, "tests")
 
     assert_equal 0, test_field.arguments.length
     assert_equal 4, conn_field.arguments.length
@@ -39,12 +47,8 @@ describe GraphQL::Relay::ConnectionField do
   end
 
   it "passes connection behaviors to redefinitions" do
-    test_type = GraphQL::ObjectType.define do
-      name "Test"
-      connection :tests, test_type.connection_type
-    end
-
-    connection_field = test_type.fields["tests"]
+    _test_field, test_schema = build_schema
+    connection_field = test_schema.get_field(test_schema.query, "tests")
     redefined_connection_field = connection_field.redefine { argument "name", types.String }
 
     assert_equal 4, connection_field.arguments.size

data/spec/graphql/static_validation/rules/fields_will_merge_spec.rb

@@ -422,19 +422,28 @@ describe GraphQL::StaticValidation::FieldsWillMerge do
       {
         pet {
           ... on Dog {
-            name(surname: true)
+            ...X
           }
           ... on Cat {
-            name
+            ...Y
           }
         }
       }
+
+      fragment X on Pet {
+        name(surname: true)
+      }
+
+      fragment Y on Pet {
+        name
+      }
     |}
 
     it "passes rule" do
       assert_equal [], errors
     end
   end
+
   describe "return types must be unambiguous" do
     let(:schema) {
       GraphQL::Schema.from_definition(%|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.5.7.1
+  version: 1.5.8
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-09 00:00:00.000000000 Z
+date: 2017-04-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -363,6 +363,7 @@ files:
 - lib/graphql/interface_type.rb
 - lib/graphql/internal_representation.rb
 - lib/graphql/internal_representation/node.rb
+- lib/graphql/internal_representation/print.rb
 - lib/graphql/internal_representation/rewrite.rb
 - lib/graphql/internal_representation/scope.rb
 - lib/graphql/internal_representation/visit.rb
@@ -420,7 +421,7 @@ files:
 - lib/graphql/relay.rb
 - lib/graphql/relay/array_connection.rb
 - lib/graphql/relay/base_connection.rb
-- lib/graphql/relay/connection_field.rb
+- lib/graphql/relay/connection_instrumentation.rb
 - lib/graphql/relay/connection_resolve.rb
 - lib/graphql/relay/connection_type.rb
 - lib/graphql/relay/edge.rb
@@ -533,6 +534,7 @@ files:
 - spec/graphql/input_object_type_spec.rb
 - spec/graphql/int_type_spec.rb
 - spec/graphql/interface_type_spec.rb
+- spec/graphql/internal_representation/print_spec.rb
 - spec/graphql/internal_representation/rewrite_spec.rb
 - spec/graphql/introspection/directive_type_spec.rb
 - spec/graphql/introspection/input_value_type_spec.rb
@@ -558,7 +560,7 @@ files:
 - spec/graphql/query_spec.rb
 - spec/graphql/relay/array_connection_spec.rb
 - spec/graphql/relay/base_connection_spec.rb
-- spec/graphql/relay/connection_field_spec.rb
+- spec/graphql/relay/connection_instrumentation_spec.rb
 - spec/graphql/relay/connection_resolve_spec.rb
 - spec/graphql/relay/connection_type_spec.rb
 - spec/graphql/relay/mutation_spec.rb
@@ -679,6 +681,7 @@ test_files:
 - spec/graphql/input_object_type_spec.rb
 - spec/graphql/int_type_spec.rb
 - spec/graphql/interface_type_spec.rb
+- spec/graphql/internal_representation/print_spec.rb
 - spec/graphql/internal_representation/rewrite_spec.rb
 - spec/graphql/introspection/directive_type_spec.rb
 - spec/graphql/introspection/input_value_type_spec.rb
@@ -704,7 +707,7 @@ test_files:
 - spec/graphql/query_spec.rb
 - spec/graphql/relay/array_connection_spec.rb
 - spec/graphql/relay/base_connection_spec.rb
-- spec/graphql/relay/connection_field_spec.rb
+- spec/graphql/relay/connection_instrumentation_spec.rb
 - spec/graphql/relay/connection_resolve_spec.rb
 - spec/graphql/relay/connection_type_spec.rb
 - spec/graphql/relay/mutation_spec.rb