graphql 1.2.4 → 1.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f79f91876d8a49ea48c4d551a073491c33eefc31
-  data.tar.gz: 3e91b2b21c60df562e95879a4a8fd24f214553e2
+  metadata.gz: b49f51c993d3f37fb6596a0547175b9cb1e6dfe0
+  data.tar.gz: 4e639bf70ca713dd8a795690a30b2eafca16c5be
 SHA512:
-  metadata.gz: 86a409aedbc0f2261b80b1f4cbca9e5fcc529abdb609557299de5547ff554e5f98a35188dcf6ba1a82650995f8989d867738c98aeafda4de7686b33932dff371
-  data.tar.gz: 23135beccd828141bb898bd12514899a0125035f38284146f2941a36e5117449854759e6b202937996e078782123e7f87437f5244be6af392186fd8d1d798cdc
+  metadata.gz: 8ba6eec79d60b4e4fac5a3779dce895c9e757e3bd923b64d6d77b2702638ed2dcb6b57ae914a6be2e582cff6cad29a3f3f18662e90b7ff5076f56610c75c2519
+  data.tar.gz: 39e999428ae079e15e942852e295518bb242b6c4dcb65ca32f31cdcde7d2518427f34dbd39d5b92a8e72d70762f85d0e85079d4efe4d670bf2ea674f98e542f8

data/lib/graphql/define/assign_object_field.rb

@@ -16,13 +16,13 @@ module GraphQL
         # Figure out how to find or initialize the field instance:
         if type_or_field.is_a?(GraphQL::Field)
           field = type_or_field
-          field.name ||= name_s
+          field = field.redefine(name: name_s)
         elsif block_given?
           field = GraphQL::Field.define(kwargs, &block)
         elsif field.nil?
           field = GraphQL::Field.define(kwargs)
         elsif field.is_a?(GraphQL::Field)
-          field.name ||= name_s
+          field = field.redefine(name: name_s)
         else
           raise("Couldn't find a field argument, received: #{field || type_or_field}")
         end

data/lib/graphql/define/instance_definable.rb

@@ -100,7 +100,7 @@ module GraphQL
       def redefine(**kwargs, &block)
         ensure_defined
         new_instance = self.class.new
-        applied_definitions.each { |defn| defn.apply(new_instance) }
+        applied_definitions.each { |defn| new_instance.define(defn.define_keywords, &defn.define_proc) }
         new_instance.define(**kwargs, &block)
         new_instance
       end
@@ -116,7 +116,16 @@ module GraphQL
         if @pending_definition
           defn = @pending_definition
           @pending_definition = nil
-          defn.apply(self)
+          defn_proxy = DefinedObjectProxy.new(self)
+          # Apply definition from `define(...)` kwargs
+          defn.define_keywords.each do |keyword, value|
+            defn_proxy.public_send(keyword, value)
+          end
+          # and/or apply definition from `define { ... }` block
+          if defn.define_proc
+            defn_proxy.instance_eval(&defn.define_proc)
+          end
+
           applied_definitions << defn
         end
         nil
@@ -126,24 +135,12 @@ module GraphQL
         @applied_definitions ||= []
       end
 
-
       class Definition
+        attr_reader :define_keywords, :define_proc
         def initialize(define_keywords, define_proc)
           @define_keywords = define_keywords
           @define_proc = define_proc
         end
-
-        def apply(instance)
-          defn_proxy = DefinedObjectProxy.new(instance)
-
-          @define_keywords.each do |keyword, value|
-            defn_proxy.public_send(keyword, value)
-          end
-
-          if @define_proc
-            defn_proxy.instance_eval(&@define_proc)
-          end
-        end
       end
 
       module ClassMethods

data/lib/graphql/field.rb

@@ -123,13 +123,19 @@ module GraphQL
     accepts_definitions :name, :description, :deprecation_reason,
       :resolve, :type, :arguments,
       :property, :hash_key, :complexity, :mutation,
+      :relay_node_field,
       argument: GraphQL::Define::AssignArgument
 
 
     attr_accessor :name, :deprecation_reason, :description, :property, :hash_key, :mutation, :arguments, :complexity
+
+    # @return [Boolean] True if this is the Relay find-by-id field
+    attr_accessor :relay_node_field
+
     ensure_defined(
-      :name, :deprecation_reason, :description, :property, :hash_key, :mutation, :arguments, :complexity,
-      :resolve, :resolve=, :type, :type=, :name=, :property=, :hash_key=
+      :name, :deprecation_reason, :description, :description=, :property, :hash_key, :mutation, :arguments, :complexity,
+      :resolve, :resolve=, :type, :type=, :name=, :property=, :hash_key=,
+      :relay_node_field,
     )
 
     # @!attribute [r] resolve_proc
@@ -152,6 +158,7 @@ module GraphQL
       @complexity = 1
       @arguments = {}
       @resolve_proc = build_default_resolver
+      @relay_node_field = false
     end
 
     # Get a value for this field

data/lib/graphql/input_object_type.rb

@@ -30,9 +30,8 @@ module GraphQL
     )
 
     attr_accessor :mutation, :arguments
-    alias :input_fields :arguments
-
     ensure_defined(:mutation, :arguments)
+    alias :input_fields :arguments
 
     # @!attribute mutation
     #   @return [GraphQL::Relay::Mutation, nil] The mutation this field was derived from, if it was derived from a mutation

data/lib/graphql/language/visitor.rb

@@ -17,16 +17,9 @@ module GraphQL
       # node right away
       SKIP = :_skip
 
-      # @return [Array<Proc>] Hooks to call when entering _any_ node
-      attr_reader :enter
-      # @return [Array<Proc>] Hooks to call when leaving _any_ node
-      attr_reader :leave
-
       def initialize(document)
         @document = document
         @visitors = {}
-        @enter = []
-        @leave = []
       end
 
       # Get a {NodeVisitor} for `node_class`
@@ -50,20 +43,18 @@ module GraphQL
       def visit_node(node, parent)
         begin_hooks_ok = begin_visit(node, parent)
         if begin_hooks_ok
-          node.children.reduce(true) { |memo, child| memo && visit_node(child, node) }
+          node.children.each { |child| visit_node(child, node) }
         end
         end_visit(node, parent)
       end
 
       def begin_visit(node, parent)
-        self.class.apply_hooks(enter, node, parent)
         node_visitor = self[node.class]
         self.class.apply_hooks(node_visitor.enter, node, parent)
       end
 
       # Should global `leave` visitors come first or last?
       def end_visit(node, parent)
-        self.class.apply_hooks(leave, node, parent)
         node_visitor = self[node.class]
         self.class.apply_hooks(node_visitor.leave, node, parent)
       end

data/lib/graphql/query.rb

@@ -240,6 +240,7 @@ module GraphQL
       def call
         @instrumenters.each { |i| i.before_query(@query) }
         result = get_result
+      ensure
         @instrumenters.each { |i| i.after_query(@query) }
         result
       end

data/lib/graphql/query/arguments.rb

@@ -60,19 +60,23 @@ module GraphQL
       NULL_ARGUMENT_VALUE = ArgumentValue.new(nil, nil, nil)
 
       def wrap_value(value, arg_defn_type)
-        case arg_defn_type
-        when GraphQL::ListType
-          value.map { |item| wrap_value(item, arg_defn_type.of_type) }
-        when GraphQL::NonNullType
-          wrap_value(value, arg_defn_type.of_type)
-        when GraphQL::InputObjectType
-          if value.is_a?(Hash)
-            self.class.new(value, argument_definitions: arg_defn_type.arguments)
+        if value.nil?
+          nil
+        else
+          case arg_defn_type
+          when GraphQL::ListType
+            value.map { |item| wrap_value(item, arg_defn_type.of_type) }
+          when GraphQL::NonNullType
+            wrap_value(value, arg_defn_type.of_type)
+          when GraphQL::InputObjectType
+            if value.is_a?(Hash)
+              self.class.new(value, argument_definitions: arg_defn_type.arguments)
+            else
+              value
+            end
           else
             value
           end
-        else
-          value
         end
       end
 

data/lib/graphql/relay/connection_field.rb

@@ -27,7 +27,7 @@ module GraphQL
       # Turn A GraphQL::Field into a connection by:
       # - Merging in the default arguments
       # - Transforming its resolve function to return a connection object
-      # @param [GraphQL::Field] A field which returns nodes to be wrapped as a connection
+      # @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] The same field, modified to resolve to a connection object
       def self.create(underlying_field, max_page_size: nil)

data/lib/graphql/relay/mutation.rb

@@ -148,7 +148,7 @@ module GraphQL
         attr_reader :client_mutation_id
         def initialize(client_mutation_id:, result:)
           @client_mutation_id = client_mutation_id
-          result.each do |key, value|
+          result && result.each do |key, value|
             self.public_send("#{key}=", value)
           end
         end
@@ -175,6 +175,12 @@ module GraphQL
 
         def call(obj, args, ctx)
           mutation_result = @resolve.call(obj, args[:input], ctx)
+
+          if mutation_result.is_a?(GraphQL::ExecutionError)
+            ctx.add_error(mutation_result)
+            mutation_result = nil
+          end
+
           if @wrap_result
             @mutation.result_class.new(client_mutation_id: args[:input][:clientMutationId], result: mutation_result)
           else

data/lib/graphql/relay/node.rb

@@ -7,17 +7,13 @@ module GraphQL
         # We have to define it fresh each time because
         # its name will be modified and its description
         # _may_ be modified.
-        node_field = GraphQL::Field.define do
+        GraphQL::Field.define do
           type(GraphQL::Relay::Node.interface)
           description("Fetches an object given its ID.")
           argument(:id, !types.ID, "ID of the object.")
           resolve(GraphQL::Relay::Node::FindNode)
+          relay_node_field(true)
         end
-
-        # This is used to identify generated fields in the schema
-        node_field.metadata[:relay_node_field] = true
-
-        node_field
       end
 
       # @return [GraphQL::InterfaceType] The interface which all Relay types must implement

data/lib/graphql/schema.rb

@@ -109,27 +109,24 @@ module GraphQL
       ensure_defined
       all_types = orphan_types + [query, mutation, subscription, GraphQL::Introspection::SchemaType]
       @types = GraphQL::Schema::ReduceTypes.reduce(all_types.compact)
-
-      @instrumented_field_map = InstrumentedFieldMap.new(self)
-      field_instrumenters = @instrumenters[:field]
-      types.each do |type_name, type|
-        if type.kind.fields?
-          type.all_fields.each do |field_defn|
-
-            instrumented_field_defn = field_instrumenters.reduce(field_defn) do |defn, inst|
-              inst.instrument(type, defn)
-            end
-
-            @instrumented_field_map.set(type.name, field_defn.name, instrumented_field_defn)
-          end
-        end
-      end
+      build_instrumented_field_map
       # Assert that all necessary configs are present:
       validation_error = Validation.validate(self)
       validation_error && raise(NotImplementedError, validation_error)
       nil
     end
 
+    # Attach `instrumenter` to this schema for instrumenting events of `instrumentation_type`.
+    # @param instrumentation_type [Symbol]
+    # @param instrumenter
+    # @return [void]
+    def instrument(instrumentation_type, instrumenter)
+      @instrumenters[instrumentation_type] << instrumenter
+      if instrumentation_type == :field
+        build_instrumented_field_map
+      end
+    end
+
 
     # @see [GraphQL::Schema::Warden] Restricted access to members of a schema
     # @return [GraphQL::Schema::TypeMap] `{ name => type }` pairs of types in this schema
@@ -289,5 +286,9 @@ module GraphQL
         middleware
       end
     end
+
+    def build_instrumented_field_map
+      @instrumented_field_map = InstrumentedFieldMap.new(self, @instrumenters[:field])
+    end
   end
 end

data/lib/graphql/schema/instrumented_field_map.rb

@@ -6,8 +6,21 @@ module GraphQL
     #
     # The catch is, the fields in this map _may_ have been modified by being instrumented.
     class InstrumentedFieldMap
-      def initialize(schema)
+      # Build a map using types from `schema` and instrumenters in `field_instrumenters`
+      # @param schema [GraphQL::Schema]
+      # @param field_instrumenters [Array<#instrument(type, field)>]
+      def initialize(schema, field_instrumenters)
         @storage = Hash.new { |h, k| h[k] = {} }
+        schema.types.each do |type_name, type|
+          if type.kind.fields?
+            type.all_fields.each do |field_defn|
+              instrumented_field_defn = field_instrumenters.reduce(field_defn) do |defn, inst|
+                inst.instrument(type, defn)
+              end
+              self.set(type.name, field_defn.name, instrumented_field_defn)
+            end
+          end
+        end
       end
 
       def set(type_name, field_name, field)

data/lib/graphql/schema/validation.rb

@@ -139,7 +139,7 @@ module GraphQL
         }
 
         SCHEMA_CAN_FETCH_IDS = ->(schema) {
-          has_node_field = schema.query && schema.query.all_fields.any? { |f| f.metadata[:relay_node_field] }
+          has_node_field = schema.query && schema.query.all_fields.any?(&:relay_node_field)
           if has_node_field && schema.object_from_id_proc.nil?
             "schema contains `node(id:...)` field, so you must define a `object_from_id (id, ctx) -> { ... }` function"
           else

data/lib/graphql/static_validation/all_rules.rb

@@ -8,6 +8,7 @@ module GraphQL
     ALL_RULES = [
       GraphQL::StaticValidation::DirectivesAreDefined,
       GraphQL::StaticValidation::DirectivesAreInValidLocations,
+      GraphQL::StaticValidation::UniqueDirectivesPerLocation,
       GraphQL::StaticValidation::FragmentsAreFinite,
       GraphQL::StaticValidation::FragmentsAreNamed,
       GraphQL::StaticValidation::FragmentsAreUsed,

data/lib/graphql/static_validation/message.rb

@@ -1,23 +1,22 @@
 module GraphQL
   module StaticValidation
     # Generates GraphQL-compliant validation message.
-    # Only supports one "location", too bad :(
     class Message
       # Convenience for validators
       module MessageHelper
         # Error `message` is located at `node`
-        def message(message, node, context: nil, path: nil)
+        def message(message, nodes, context: nil, path: nil)
           path ||= context.path
-          GraphQL::StaticValidation::Message.new(message, line: node.line, col: node.col, path: path)
+          nodes = Array(nodes)
+          GraphQL::StaticValidation::Message.new(message, nodes: nodes, path: path)
         end
       end
 
-      attr_reader :message, :line, :col, :path
+      attr_reader :message, :path
 
-      def initialize(message, line: nil, col: nil, path: [])
+      def initialize(message, path: [], nodes: [])
         @message = message
-        @line = line
-        @col = col
+        @nodes = nodes
         @path = path
       end
 
@@ -33,7 +32,7 @@ module GraphQL
       private
 
       def locations
-        @line.nil? && @col.nil? ? [] : [{"line" => @line, "column" => @col}]
+        @nodes.map{|node| {"line" => node.line, "column" => node.col}}
       end
     end
   end

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

@@ -0,0 +1,38 @@
+module GraphQL
+  module StaticValidation
+    class UniqueDirectivesPerLocation
+      include GraphQL::StaticValidation::Message::MessageHelper
+
+      NODES_WITH_DIRECTIVES = GraphQL::Language::Nodes.constants
+        .map{|c| GraphQL::Language::Nodes.const_get(c)}
+        .select{|c| c.is_a?(Class) && c.instance_methods.include?(:directives)}
+
+      def validate(context)
+        NODES_WITH_DIRECTIVES.each do |node_class|
+          context.visitor[node_class] << ->(node, _) {
+            validate_directives(node, context) unless node.directives.empty?
+          }
+        end
+      end
+
+      private
+
+      def validate_directives(node, context)
+        used_directives = {}
+
+        node.directives.each do |ast_directive|
+          directive_name = ast_directive.name
+          if used_directives[directive_name]
+            context.errors << message(
+              "The directive \"#{directive_name}\" can only be used once at this location.",
+              [used_directives[directive_name], ast_directive],
+              context: context
+            )
+          else
+            used_directives[directive_name] = ast_directive
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/static_validation/type_stack.rb

@@ -41,18 +41,15 @@ module GraphQL
         @directive_definitions = []
         @argument_definitions = []
         @path = []
-        visitor.enter << ->(node, parent) { PUSH_STRATEGIES[node.class].push(self, node) }
-        visitor.leave << ->(node, parent) { PUSH_STRATEGIES[node.class].pop(self, node) }
+
+        PUSH_STRATEGIES.each do |node_class, strategy|
+          visitor[node_class].enter << EnterWithStrategy.new(self, strategy)
+          visitor[node_class].leave << LeaveWithStrategy.new(self, strategy)
+        end
       end
 
       private
 
-      # Look up strategies by name and use singleton instance to push and pop
-      PUSH_STRATEGIES = Hash.new do |hash, key|
-        node_class_name = key.name.split("::").last
-        strategy_key = "#{node_class_name}Strategy"
-        hash[key] = const_defined?(strategy_key) ? const_get(strategy_key) : NullStrategy
-      end
 
       module FragmentWithTypeStrategy
         def push(stack, node)
@@ -182,10 +179,36 @@ module GraphQL
         end
       end
 
-      # A no-op strategy (don't handle this node)
-      module NullStrategy
-        def self.push(stack, node);  end
-        def self.pop(stack, node);   end
+      PUSH_STRATEGIES = {
+        GraphQL::Language::Nodes::FragmentDefinition => FragmentDefinitionStrategy,
+        GraphQL::Language::Nodes::InlineFragment => InlineFragmentStrategy,
+        GraphQL::Language::Nodes::FragmentSpread => FragmentSpreadStrategy,
+        GraphQL::Language::Nodes::Argument => ArgumentStrategy,
+        GraphQL::Language::Nodes::Field => FieldStrategy,
+        GraphQL::Language::Nodes::Directive => DirectiveStrategy,
+        GraphQL::Language::Nodes::OperationDefinition => OperationDefinitionStrategy,
+      }
+
+      class EnterWithStrategy
+        def initialize(stack, strategy)
+          @stack = stack
+          @strategy = strategy
+        end
+
+        def call(node, parent)
+          @strategy.push(@stack, node)
+        end
+      end
+
+      class LeaveWithStrategy
+        def initialize(stack, strategy)
+          @stack = stack
+          @strategy = strategy
+        end
+
+        def call(node, parent)
+          @strategy.pop(@stack, node)
+        end
       end
     end
   end

data/lib/graphql/version.rb

@@ -1,3 +1,3 @@
 module GraphQL
-  VERSION = "1.2.4"
+  VERSION = "1.2.5"
 end

data/spec/graphql/define/instance_definable_spec.rb

@@ -18,6 +18,10 @@ module Garden
     # definition added later:
     attr_accessor :height
     ensure_defined(:height)
+
+    def color
+      metadata[:color]
+    end
   end
 end
 
@@ -84,15 +88,24 @@ describe GraphQL::Define::InstanceDefinable do
         name "Renamed Red Arugula"
       end
 
-      assert_equal :green, arugula.metadata[:color]
+      assert_equal :green, arugula.color
       assert_equal "Arugula", arugula.name
 
-      assert_equal :red, red_arugula.metadata[:color]
+      assert_equal :red, red_arugula.color
       assert_equal "Arugula", red_arugula.name
 
-      assert_equal :red, renamed_red_arugula.metadata[:color]
+      assert_equal :red, renamed_red_arugula.color
       assert_equal "Renamed Red Arugula", renamed_red_arugula.name
     end
+
+    it "can be chained several times" do
+      arugula_1 = Garden::Vegetable.define(name: "Arugula") { color :green }
+      arugula_2 = arugula_1.redefine { color :red }
+      arugula_3 = arugula_2.redefine { plant_between(1..3) }
+      assert_equal ["Arugula", :green], [arugula_1.name, arugula_1.color]
+      assert_equal ["Arugula", :red], [arugula_2.name, arugula_2.color]
+      assert_equal ["Arugula", :red], [arugula_3.name, arugula_3.color]
+    end
   end
 
   describe "#metadata" do

data/spec/graphql/field_spec.rb

@@ -120,4 +120,34 @@ describe GraphQL::Field do
       assert_equal [:cheeses, :milks], similar_cheese_field.metadata[:joins]
     end
   end
+
+  describe "reusing a GraphQL::Field" do
+    let(:schema) {
+      int_field = GraphQL::Field.define do
+        type types.Int
+        argument :value, types.Int
+        resolve -> (obj, args, ctx) { args[:value] }
+      end
+
+      query_type = GraphQL::ObjectType.define do
+        name "Query"
+        field :int, int_field
+        field :int2, int_field
+        field :int3, field: int_field
+      end
+
+      GraphQL::Schema.define do
+        query(query_type)
+      end
+    }
+
+    it "can be used in two places" do
+      res = schema.execute %|{ int(value: 1) int2(value: 2) int3(value: 3) }|
+      assert_equal({ "int" => 1, "int2" => 2, "int3" => 3}, res["data"], "It works in queries")
+
+      res = schema.execute %|{ __type(name: "Query") { fields { name } } }|
+      query_field_names = res["data"]["__type"]["fields"].map { |f| f["name"] }
+      assert_equal ["int", "int2", "int3"], query_field_names, "It works in introspection"
+    end
+  end
 end

data/spec/graphql/input_object_type_spec.rb

@@ -10,6 +10,18 @@ describe GraphQL::InputObjectType do
     assert(DairyProductInputType.input_fields["fatContent"])
   end
 
+  describe "on a type unused by the schema" do
+    it "has input fields" do
+      UnreachedInputType = GraphQL::InputObjectType.define do
+        name 'UnreachedInputType'
+        description 'An input object type not directly used in the schema.'
+
+        input_field :field, types.String
+      end
+      assert(UnreachedInputType.input_fields['field'])
+    end
+  end
+
   describe "input validation" do
     it "Accepts anything that yields key-value pairs to #all?" do
       values_obj = MinimumInputObject.new({"source" => "COW", "fatContent" => 0.4})

data/spec/graphql/query/variables_spec.rb

@@ -2,30 +2,69 @@ require "spec_helper"
 
 describe GraphQL::Query::Variables do
   let(:query_string) {%|
-  query getCheese($animals: [DairyAnimal], $int: Int, $intWithDefault: Int = 10) {
+  query getCheese($animals: [DairyAnimal!], $int: Int, $intWithDefault: Int = 10) {
     cheese(id: 1) {
       similarCheese(source: $animals)
     }
   }
   |}
   let(:ast_variables) { GraphQL.parse(query_string).definitions.first.variables }
+  let(:schema) { DummySchema }
   let(:variables) { GraphQL::Query::Variables.new(
-    DummySchema,
-    GraphQL::Schema::Warden.new(DummySchema, GraphQL::Query::NullExcept),
+    schema,
+    GraphQL::Schema::Warden.new(schema, GraphQL::Query::NullExcept),
     ast_variables,
     provided_variables)
   }
 
   describe "#initialize" do
     describe "coercing inputs" do
-      let(:provided_variables) {
-        {"animals" => "YAK"}
-      }
+      let(:provided_variables) { { "animals" => "YAK" } }
+
       it "coerces single items into one-element lists" do
         assert_equal ["YAK"], variables["animals"]
       end
     end
 
+    describe "nullable variables" do
+      let(:schema) { GraphQL::Schema.from_definition(%|
+        type Query {
+          thingsCount(ids: [ID!]): Int!
+        }
+      |)
+      }
+      let(:query_string) {%|
+        query getThingsCount($ids: [ID!]) {
+          thingsCount(ids: $ids)
+        }
+      |}
+      let(:result) {
+        schema.execute(query_string, variables: provided_variables, root_value: OpenStruct.new(thingsCount: 1))
+      }
+
+      describe "when they are present, but null" do
+        let(:provided_variables) { { "ids" => nil } }
+        it "ignores them" do
+          assert_equal 1, result["data"]["thingsCount"]
+        end
+      end
+
+      describe "when they are not present" do
+        let(:provided_variables) { {} }
+        it "ignores them" do
+          assert_equal 1, result["data"]["thingsCount"]
+        end
+      end
+
+      describe "when a nullable list has a null in it" do
+        let(:provided_variables) { { "ids" => [nil] } }
+        it "returns an error" do
+          assert_equal 1, result["errors"].length
+          assert_equal nil, result["data"]
+        end
+      end
+    end
+
     describe "coercing null" do
       let(:provided_variables) {
         {"int" => nil, "intWithDefault" => nil}

data/spec/graphql/relay/connection_field_spec.rb

@@ -9,4 +9,26 @@ describe GraphQL::Relay::ConnectionField do
 
     assert_equal ["tests"], test_type.fields.keys
   end
+
+  it "leaves the original field untouched" do
+    test_type = nil
+
+    test_field = GraphQL::Field.define do
+      type(test_type.connection_type)
+      property(:something)
+    end
+
+    test_type = GraphQL::ObjectType.define do
+      name "Test"
+      connection :tests, test_field
+    end
+
+    conn_field = test_type.fields["tests"]
+
+    assert_equal 0, test_field.arguments.length
+    assert_equal 4, conn_field.arguments.length
+
+    assert_instance_of GraphQL::Field::Resolve::MethodResolve, test_field.resolve_proc
+    assert_instance_of GraphQL::Relay::ConnectionResolve, conn_field.resolve_proc
+  end
 end

data/spec/graphql/relay/mutation_spec.rb

@@ -77,6 +77,23 @@ describe GraphQL::Relay::Mutation do
     assert_equal IntroduceShipMutation, IntroduceShipMutation.result_class.mutation
   end
 
+  describe "aliased methods" do
+    describe "on an unreached mutation" do
+      it 'still ensures definitions' do
+        UnreachedMutation = GraphQL::Relay::Mutation.define do
+          name 'UnreachedMutation'
+          description 'A mutation type not directly used in the schema.'
+
+          input_field :input, types.String
+          return_field :return, types.String
+        end
+
+        assert UnreachedMutation.input_fields['input']
+        assert UnreachedMutation.return_fields['return']
+      end
+    end
+  end
+
   describe "providing a return type" do
     let(:custom_return_type) {
       GraphQL::ObjectType.define do
@@ -143,4 +160,29 @@ describe GraphQL::Relay::Mutation do
       assert_equal "String", input.arguments['stringDefault'].default_value
     end
   end
+
+  describe "handling errors" do
+    it "supports returning an error in resolve" do
+      result = star_wars_query(query_string, "clientMutationId" => "5678", "shipName" => "Millennium Falcon")
+
+      expected = {
+        "data" => {
+          "introduceShip" => {
+            "clientMutationId" => "5678",
+            "shipEdge" => nil,
+            "faction" => nil,
+          }
+        },
+        "errors" => [
+          {
+            "message" => "Sorry, Millennium Falcon ship is reserved",
+            "locations" => [ { "line" => 3 , "column" => 7}],
+            "path" => ["introduceShip"]
+          }
+        ]
+      }
+
+      assert_equal(expected, result)
+    end
+  end
 end

data/spec/graphql/schema_spec.rb

@@ -217,6 +217,7 @@ type Query {
       end
 
       def after_query(query)
+        @counts << :end
       end
     end
 
@@ -228,7 +229,7 @@ type Query {
         name "Query"
         field :int, types.Int do
           argument :value, types.Int
-          resolve -> (obj, args, ctx) { args[:value] }
+          resolve -> (obj, args, ctx) { args[:value] == 13 ? raise("13 is unlucky") : args[:value] }
         end
       end
     }
@@ -250,7 +251,24 @@ type Query {
     it "can wrap query execution" do
       schema.execute("query getInt($val: Int = 5){ int(value: $val) } ")
       schema.execute("query getInt($val: Int = 5, $val2: Int = 3){ int(value: $val) int2: int(value: $val2) } ")
-      assert_equal [1, 2], variable_counter.counts
+      assert_equal [1, :end, 2, :end], variable_counter.counts
+    end
+
+    it "runs even when a runtime error occurs" do
+      schema.execute("query getInt($val: Int = 5){ int(value: $val) } ")
+      assert_raises(RuntimeError) {
+        schema.execute("query getInt($val: Int = 13){ int(value: $val) } ")
+      }
+      assert_equal [1, :end, 1, :end], variable_counter.counts
+    end
+
+    it "can be applied after the fact" do
+      res = schema.execute("query { int(value: 2) } ")
+      assert_equal 6, res["data"]["int"]
+
+      schema.instrument(:field, MultiplyInstrumenter.new(4))
+      res = schema.execute("query { int(value: 2) } ")
+      assert_equal 24, res["data"]["int"]
     end
   end
 end

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

@@ -0,0 +1,180 @@
+require "spec_helper"
+
+describe GraphQL::StaticValidation::UniqueDirectivesPerLocation do
+  include StaticValidationHelpers
+
+  let(:schema) { GraphQL::Schema.from_definition("
+    type Query {
+      type: Type
+    }
+
+    type Type {
+      field: String
+    }
+
+    directive @A on FIELD
+    directive @B on FIELD
+  ") }
+
+  describe "query with no directives" do
+    let(:query_string) {"
+      {
+        type {
+          field
+        }
+      }
+    "}
+
+    it "passes rule" do
+      assert_equal [], errors
+    end
+  end
+
+  describe "query with unique directives in different locations" do
+    let(:query_string) {"
+      {
+        type @A {
+          field @B
+        }
+      }
+    "}
+
+    it "passes rule" do
+      assert_equal [], errors
+    end
+  end
+
+  describe "query with unique directives in same locations" do
+    let(:query_string) {"
+      {
+        type @A @B {
+          field @A @B
+        }
+      }
+    "}
+
+    it "passes rule" do
+      assert_equal [], errors
+    end
+  end
+
+  describe "query with same directives in different locations" do
+    let(:query_string) {"
+      {
+        type @A {
+          field @A
+        }
+      }
+    "}
+
+    it "passes rule" do
+      assert_equal [], errors
+    end
+  end
+
+  describe "query with same directives in similar locations" do
+    let(:query_string) {"
+      {
+        type {
+          field @A
+          field @A
+        }
+      }
+    "}
+
+    it "passes rule" do
+      assert_equal [], errors
+    end
+  end
+
+  describe "query with duplicate directives in one location" do
+    let(:query_string) {"
+      {
+        type {
+          field @A @A
+        }
+      }
+    "}
+
+    it "fails rule" do
+      assert_includes errors, {
+        "message" => 'The directive "A" can only be used once at this location.',
+        "locations" => [{ "line" => 4, "column" => 17 }, { "line" => 4, "column" => 20 }],
+        "fields" => ["query", "type", "field"],
+      }
+    end
+  end
+
+
+  describe "query with many duplicate directives in one location" do
+    let(:query_string) {"
+      {
+        type {
+          field @A @A @A
+        }
+      }
+    "}
+
+    it "fails rule" do
+      assert_includes errors, {
+        "message" => 'The directive "A" can only be used once at this location.',
+        "locations" => [{ "line" => 4, "column" => 17 }, { "line" => 4, "column" => 20 }],
+        "fields" => ["query", "type", "field"],
+      }
+
+      assert_includes errors, {
+        "message" => 'The directive "A" can only be used once at this location.',
+        "locations" => [{ "line" => 4, "column" => 17 }, { "line" => 4, "column" => 23 }],
+        "fields" => ["query", "type", "field"],
+      }
+    end
+  end
+
+  describe "query with different duplicate directives in one location" do
+    let(:query_string) {"
+      {
+        type {
+          field @A @B @A @B
+        }
+      }
+    "}
+
+    it "fails rule" do
+      assert_includes errors, {
+        "message" => 'The directive "A" can only be used once at this location.',
+        "locations" => [{ "line" => 4, "column" => 17 }, { "line" => 4, "column" => 23 }],
+        "fields" => ["query", "type", "field"],
+      }
+
+      assert_includes errors, {
+        "message" => 'The directive "B" can only be used once at this location.',
+        "locations" => [{ "line" => 4, "column" => 20 }, { "line" => 4, "column" => 26 }],
+        "fields" => ["query", "type", "field"],
+      }
+    end
+  end
+
+  describe "query with duplicate directives in many locations" do
+    let(:query_string) {"
+      {
+        type @A @A {
+          field @A @A
+        }
+      }
+    "}
+
+    it "fails rule" do
+      assert_includes errors, {
+        "message" => 'The directive "A" can only be used once at this location.',
+        "locations" => [{ "line" => 3, "column" => 14 }, { "line" => 3, "column" => 17 }],
+        "fields" => ["query", "type"],
+      }
+
+      assert_includes errors, {
+        "message" => 'The directive "A" can only be used once at this location.',
+        "locations" => [{ "line" => 4, "column" => 17 }, { "line" => 4, "column" => 20 }],
+        "fields" => ["query", "type", "field"],
+      }
+    end
+  end
+end

data/spec/support/star_wars_schema.rb

@@ -157,6 +157,7 @@ IntroduceShipMutation = GraphQL::Relay::Mutation.define do
   # Here's the mutation operation:
   resolve ->(root_obj, inputs, ctx) {
     faction_id = inputs["factionId"]
+    return GraphQL::ExecutionError.new("Sorry, Millennium Falcon ship is reserved") if inputs["shipName"] == 'Millennium Falcon'
     ship = STAR_WARS_DATA.create_ship(inputs["shipName"], faction_id)
     faction = STAR_WARS_DATA["Faction"][faction_id]
     connection_class = GraphQL::Relay::BaseConnection.connection_for_nodes(faction.ships)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.2.4
+  version: 1.2.5
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-18 00:00:00.000000000 Z
+date: 2016-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: codeclimate-test-reporter
@@ -407,6 +407,7 @@ files:
 - lib/graphql/static_validation/rules/mutation_root_exists.rb
 - lib/graphql/static_validation/rules/required_arguments_are_present.rb
 - lib/graphql/static_validation/rules/subscription_root_exists.rb
+- lib/graphql/static_validation/rules/unique_directives_per_location.rb
 - lib/graphql/static_validation/rules/variable_default_values_are_correctly_typed.rb
 - lib/graphql/static_validation/rules/variable_usages_are_allowed.rb
 - lib/graphql/static_validation/rules/variables_are_input_types.rb
@@ -504,6 +505,7 @@ files:
 - spec/graphql/static_validation/rules/mutation_root_exists_spec.rb
 - spec/graphql/static_validation/rules/required_arguments_are_present_spec.rb
 - spec/graphql/static_validation/rules/subscription_root_exists_spec.rb
+- spec/graphql/static_validation/rules/unique_directives_per_location_spec.rb
 - spec/graphql/static_validation/rules/variable_default_values_are_correctly_typed_spec.rb
 - spec/graphql/static_validation/rules/variable_usages_are_allowed_spec.rb
 - spec/graphql/static_validation/rules/variables_are_input_types_spec.rb
@@ -628,6 +630,7 @@ test_files:
 - spec/graphql/static_validation/rules/mutation_root_exists_spec.rb
 - spec/graphql/static_validation/rules/required_arguments_are_present_spec.rb
 - spec/graphql/static_validation/rules/subscription_root_exists_spec.rb
+- spec/graphql/static_validation/rules/unique_directives_per_location_spec.rb
 - spec/graphql/static_validation/rules/variable_default_values_are_correctly_typed_spec.rb
 - spec/graphql/static_validation/rules/variable_usages_are_allowed_spec.rb
 - spec/graphql/static_validation/rules/variables_are_input_types_spec.rb