graphql 1.7.4 → 1.7.5

data/lib/graphql/language/parser.y

@@ -78,8 +78,8 @@ rule
     | LBRACKET type RBRACKET { return make_node(:ListType, of_type: val[1]) }
 
   default_value_opt:
-      /* none */          { return nil }
-    | EQUALS input_value  { return val[1] }
+      /* none */            { return nil }
+    | EQUALS literal_value  { return val[1] }
 
   selection_set:
       LCURLY RCURLY                { return [] }
@@ -176,17 +176,21 @@ rule
   argument:
       name COLON input_value { return make_node(:Argument, name: val[0], value: val[2], position_source: val[0])}
 
-  input_value:
+  literal_value:
       FLOAT       { return val[0].to_f }
     | INT         { return val[0].to_i }
     | STRING      { return val[0].to_s }
     | TRUE        { return true }
     | FALSE       { return false }
     | null_value
-    | variable
+    | enum_value
     | list_value
+    | object_literal_value
+
+  input_value:
+    | literal_value
+    | variable
     | object_value
-    | enum_value
 
   null_value: NULL { return make_node(:NullValue, name: val[0], position_source: val[0]) }
   variable: VAR_SIGN name { return make_node(:VariableIdentifier, name: val[1], position_source: val[0]) }
@@ -210,6 +214,18 @@ rule
   object_value_field:
       name COLON input_value { return make_node(:Argument, name: val[0], value: val[2], position_source: val[0])}
 
+  /* like the previous, but with literals only: */
+  object_literal_value:
+      LCURLY RCURLY                           { return make_node(:InputObject, arguments: [], position_source: val[0])}
+    | LCURLY object_literal_value_list RCURLY { return make_node(:InputObject, arguments: val[1], position_source: val[0])}
+
+  object_literal_value_list:
+      object_literal_value_field                            { return [val[0]] }
+    | object_literal_value_list object_literal_value_field  { val[0] << val[1] }
+
+  object_literal_value_field:
+      name COLON literal_value { return make_node(:Argument, name: val[0], value: val[2], position_source: val[0])}
+
   enum_value: enum_name { return make_node(:Enum, name: val[0], position_source: val[0]) }
 
   directives_list_opt:

data/lib/graphql/list_type.rb

@@ -49,6 +49,10 @@ module GraphQL
       ensure_array(value).map { |item| item.nil? ? nil : of_type.coerce_result(item, ctx) }
     end
 
+    def list?
+      true
+    end
+
     private
 
     def coerce_non_null_input(value, ctx)

data/lib/graphql/non_null_type.rb

@@ -62,7 +62,7 @@ module GraphQL
       end
     end
 
-    def_delegators :@of_type, :coerce_input, :coerce_result
+    def_delegators :@of_type, :coerce_input, :coerce_result, :list?
 
     def kind
       GraphQL::TypeKinds::NON_NULL
@@ -72,5 +72,9 @@ module GraphQL
       "#{of_type.to_s}!"
     end
     alias_method :inspect, :to_s
+
+    def non_null?
+      true
+    end
   end
 end

data/lib/graphql/query.rb

@@ -137,6 +137,9 @@ module GraphQL
       end
     end
 
+    # @api private
+    attr_reader :result_values
+
     def fragments
       with_prepared_ast { @fragments }
     end

data/lib/graphql/static_validation/all_rules.rb

@@ -24,6 +24,7 @@ module GraphQL
       GraphQL::StaticValidation::ArgumentsAreDefined,
       GraphQL::StaticValidation::ArgumentLiteralsAreCompatible,
       GraphQL::StaticValidation::RequiredArgumentsArePresent,
+      GraphQL::StaticValidation::VariableNamesAreUnique,
       GraphQL::StaticValidation::VariablesAreInputTypes,
       GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTyped,
       GraphQL::StaticValidation::VariablesAreUsedAndDefined,

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class VariableNamesAreUnique
+      include GraphQL::StaticValidation::Message::MessageHelper
+
+      def validate(context)
+        context.visitor[GraphQL::Language::Nodes::OperationDefinition] << ->(node, parent) {
+          var_defns = node.variables
+          if var_defns.any?
+            vars_by_name = Hash.new { |h, k| h[k] = [] }
+            var_defns.each { |v| vars_by_name[v.name] << v }
+            vars_by_name.each do |name, defns|
+              if defns.size > 1
+                context.errors << message("There can only be one variable named \"#{name}\"", defns, context: context)
+              end
+            end
+          end
+        }
+      end
+    end
+  end
+end

data/lib/graphql/subscriptions.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require "securerandom"
 require "graphql/subscriptions/event"
 require "graphql/subscriptions/instrumentation"
 require "graphql/subscriptions/serialize"
@@ -133,5 +134,10 @@ module GraphQL
     def write_subscription(query, events)
       raise NotImplementedError
     end
+
+    # @return [String] A new unique identifier for a subscription
+    def build_id
+      SecureRandom.uuid
+    end
   end
 end

data/lib/graphql/subscriptions/action_cable_subscriptions.rb

@@ -1,6 +1,4 @@
 # frozen_string_literal: true
-require "securerandom"
-
 module GraphQL
   class Subscriptions
     # A subscriptions implementation that sends data
@@ -41,7 +39,7 @@ module GraphQL
     #       })
     #
     #       payload = {
-    #         result: result.to_h,
+    #         result: result.subscription? ? nil : result.to_h,
     #         more: result.subscription?,
     #       }
     #
@@ -93,7 +91,7 @@ module GraphQL
       # and re-evaluate the query locally.
       def write_subscription(query, events)
         channel = query.context[:channel]
-        subscription_id = query.context[:subscription_id] ||= SecureRandom.uuid
+        subscription_id = query.context[:subscription_id] ||= build_id
         stream = query.context[:action_cable_stream] ||= SUBSCRIPTION_PREFIX + subscription_id
         channel.stream_from(stream)
         @subscriptions[subscription_id] = query

data/lib/graphql/subscriptions/serialize.rb

@@ -12,21 +12,13 @@ module GraphQL
       # @return [Object] An object equivalent to the one passed to {.dump}
       def load(str)
         parsed_obj = JSON.parse(str)
-        if parsed_obj.is_a?(Hash) && parsed_obj.size == 1 && parsed_obj.key?(GLOBALID_KEY)
-          GlobalID::Locator.locate(parsed_obj[GLOBALID_KEY])
-        else
-          parsed_obj
-        end
+        load_value(parsed_obj)
       end
 
       # @param obj [Object] Some subscription-related data to dump
       # @return [String] The stringified object
       def dump(obj)
-        if obj.respond_to?(:to_gid_param)
-          JSON.dump(GLOBALID_KEY => obj.to_gid_param)
-        else
-          JSON.generate(obj, quirks_mode: true)
-        end
+        JSON.generate(dump_value(obj), quirks_mode: true)
       end
 
       # This is for turning objects into subscription scopes.
@@ -47,6 +39,40 @@ module GraphQL
           obj.to_s
         end
       end
+
+      class << self
+        private
+
+        # @param value [Object] A parsed JSON object
+        # @return [Object] An object that load Global::Identification recursive
+        def load_value(value)
+          if value.is_a?(Array)
+            value.map{|item| load_value(item)}
+          elsif value.is_a?(Hash)
+            if value.size == 1 && value.key?(GLOBALID_KEY)
+              GlobalID::Locator.locate(value[GLOBALID_KEY])
+            else
+              Hash[value.map{|k, v| [k, load_value(v)]}]
+            end
+          else
+            value
+          end
+        end
+
+        # @param obj [Object] Some subscription-related data to dump
+        # @return [Object] The object that converted Global::Identification
+        def dump_value(obj)
+          if obj.is_a?(Array)
+            obj.map{|item| dump_value(item)}
+          elsif obj.is_a?(Hash)
+            Hash[obj.map{|k, v| [k, dump_value(v)]}]
+          elsif obj.respond_to?(:to_gid_param)
+            {GLOBALID_KEY => obj.to_gid_param}
+          else
+            obj
+          end
+        end
+      end
     end
   end
 end

data/lib/graphql/tracing/scout_tracing.rb

@@ -3,9 +3,6 @@
 module GraphQL
   module Tracing
     class ScoutTracing < PlatformTracing
-      if defined?(ScoutApm)
-        include ScoutApm::Tracer
-      end
       INSTRUMENT_OPTS = { scope: true }
 
       self.platform_keys = {
@@ -19,6 +16,11 @@ module GraphQL
         "execute_query_lazy" => "execute.graphql",
       }
 
+      def initialize
+        self.class.include ScoutApm::Tracer
+        super
+      end
+
       def platform_trace(platform_key, key, data)
         self.class.instrument("GraphQL", platform_key, INSTRUMENT_OPTS) do
           yield

data/lib/graphql/version.rb

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

data/spec/dummy/Gemfile

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
+source 'https://rubygems.org'
+
 gem 'rails'
 gem 'puma'
 gem 'capybara'
 gem 'selenium-webdriver'
-gem 'graphql', path: File.expand_path("../../", __dir__)
+gem 'graphql', path: File.expand_path('../../', __dir__)
 
 group :development do
-  gem "listen"
+  gem 'listen'
 end

data/spec/dummy/config/application.rb

@@ -10,7 +10,6 @@ require "action_view/railtie"
 require "action_cable/engine"
 require "sprockets/railtie"
 require "rails/test_unit/railtie"
-require "puma"
 
 # Require the gems listed in Gemfile, including any gems
 # you've limited to :test, :development, or :production.

data/spec/generators/graphql/install_generator_spec.rb

@@ -64,6 +64,13 @@ RUBY
     assert_file "app/controllers/graphql_controller.rb", EXPECTED_GRAPHQLS_CONTROLLER
   end
 
+  test "it allows for a user-specified install directory" do
+    run_generator(["--directory", "app/mydirectory"])
+
+    assert_file "app/mydirectory/types/.keep"
+    assert_file "app/mydirectory/mutations/.keep"
+  end
+
   test "it generates graphql-batch and relay boilerplate" do
     run_generator(["--batch", "--relay"])
     assert_file "app/graphql/loaders/.keep"

data/spec/generators/graphql/mutation_generator_spec.rb

@@ -7,7 +7,7 @@ class GraphQLGeneratorsMutationGeneratorTest < BaseGeneratorTest
 
   destination File.expand_path("../../../tmp/dummy", File.dirname(__FILE__))
 
-  setup do
+  def setup(directory = "app/graphql")
     prepare_destination
     FileUtils.cd(File.expand_path("../../../tmp", File.dirname(__FILE__))) do
       `rm -rf dummy`
@@ -15,11 +15,12 @@ class GraphQLGeneratorsMutationGeneratorTest < BaseGeneratorTest
     end
 
     FileUtils.cd(destination_root) do
-      `rails g graphql:install`
+      `rails g graphql:install --directory #{directory}`
     end
   end
 
   test "it generates an empty resolver by name" do
+    setup
     run_generator(["UpdateName"])
 
     expected_content = <<-RUBY
@@ -39,4 +40,26 @@ RUBY
 
     assert_file "app/graphql/mutations/update_name.rb", expected_content
   end
+
+  test "it allows for user-specified directory" do
+    setup "app/mydirectory"
+    run_generator(["UpdateName", "--directory", "app/mydirectory"])
+
+    expected_content = <<-RUBY
+Mutations::UpdateName = GraphQL::Relay::Mutation.define do
+  name "UpdateName"
+  # TODO: define return fields
+  # return_field :post, Types::PostType
+
+  # TODO: define arguments
+  # input_field :name, !types.String
+
+  resolve ->(obj, args, ctx) {
+    # TODO: define resolve function
+  }
+end
+RUBY
+
+    assert_file "app/mydirectory/mutations/update_name.rb", expected_content
+  end
 end

data/spec/generators/graphql/union_generator_spec.rb

@@ -47,4 +47,18 @@ RUBY
       assert_file "app/graphql/types/winged_creature_type.rb", expected_content
     end
   end
+
+  test "it accepts a user-specified directory" do
+    command = ["WingedCreature", "--directory", "app/mydirectory"]
+
+    expected_content = <<-RUBY
+Types::WingedCreatureType = GraphQL::UnionType.define do
+  name "WingedCreature"
+end
+RUBY
+
+    prepare_destination
+    run_generator(command)
+    assert_file "app/mydirectory/types/winged_creature_type.rb", expected_content
+  end
 end

data/spec/graphql/backtrace_spec.rb

@@ -21,6 +21,15 @@ describe GraphQL::Backtrace do
     def inspect; nil; end
   end
 
+  class ErrorInstrumentation
+    def self.before_query(_query)
+    end
+
+    def self.after_query(query)
+      raise "Instrumentation Boom"
+    end
+  end
+
   let(:resolvers) {
     {
       "Query" => {
@@ -113,7 +122,7 @@ describe GraphQL::Backtrace do
       assert_includes err.message, rendered_table
       # The message includes the original error message
       assert_includes err.message, "This is broken: Boom"
-      assert_includes err.message, "spec/graphql/backtrace_spec.rb:33", "It includes the original backtrace"
+      assert_includes err.message, "spec/graphql/backtrace_spec.rb:42", "It includes the original backtrace"
       assert_includes err.message, "more lines"
     end
 
@@ -165,6 +174,17 @@ describe GraphQL::Backtrace do
 
       assert_includes(err.message, rendered_table)
     end
+
+
+    it "raises original exception instead of a TracedError when error does not occur during resolving" do
+      instrumentation_schema = schema.redefine do
+        instrument(:query, ErrorInstrumentation)
+      end
+
+      assert_raises(RuntimeError) {
+        instrumentation_schema.execute(GraphQL::Introspection::INTROSPECTION_QUERY, context: { backtrace: true })
+      }
+    end
   end
 
   # This will get brittle when execution code moves between files

data/spec/graphql/base_type_spec.rb

@@ -82,4 +82,46 @@ TYPE
       assert_equal expected.chomp, post_type.to_definition(schema)
     end
   end
+
+  describe 'non_null?' do
+    let(:type) do
+      GraphQL::EnumType.define do
+        name "Hello"
+        value 'WORLD'
+      end
+    end
+
+    it "returns false for nullable types" do
+      assert_equal(type.non_null?, false)
+    end
+
+    it "returns true for non-nulls" do
+      assert_equal(type.to_non_null_type.non_null?, true)
+    end
+
+    it "returns false for a nullable list of non-nulls" do
+      assert_equal(type.to_non_null_type.to_list_type.non_null?, false)
+    end
+  end
+
+  describe 'list?' do
+    let(:type) do
+      GraphQL::EnumType.define do
+        name "Hello"
+        value 'WORLD'
+      end
+    end
+
+    it "returns false for non-list types" do
+      assert_equal(type.list?, false)
+    end
+
+    it "returns true for lists" do
+      assert_equal(type.to_list_type.list?, true)
+    end
+
+    it "returns true for a non-nullable list" do
+      assert_equal(type.to_list_type.to_non_null_type.list?, true)
+    end
+  end
 end