graphql 1.9.3 → 1.9.4

data/lib/graphql/schema/member/instrumentation.rb

@@ -28,6 +28,12 @@ module GraphQL
             wrapper_class = root_type.metadata[:type_class]
             if wrapper_class
               new_root_value = wrapper_class.authorized_new(query.root_value, query.context)
+              new_root_value = query.schema.sync_lazy(new_root_value)
+              if new_root_value.nil?
+                # This is definitely a hack,
+                # but we need some way to tell execute.rb not to run.
+                query.context[:__root_unauthorized] = true
+              end
               query.root_value = new_root_value
             end
           end

data/lib/graphql/schema/resolver.rb

@@ -168,78 +168,6 @@ module GraphQL
         public_send("load_#{name}", value)
       end
 
-      class LoadApplicationObjectFailedError < GraphQL::ExecutionError
-        # @return [GraphQL::Schema::Argument] the argument definition for the argument that was looked up
-        attr_reader :argument
-        # @return [String] The ID provided by the client
-        attr_reader :id
-        # @return [Object] The value found with this ID
-        attr_reader :object
-        def initialize(argument:, id:, object:)
-          @id = id
-          @argument = argument
-          @object = object
-          super("No object found for `#{argument.graphql_name}: #{id.inspect}`")
-        end
-      end
-
-      # Look up the corresponding object for a provided ID.
-      # By default, it uses Relay-style {Schema.object_from_id},
-      # override this to find objects another way.
-      #
-      # @param type [Class, Module] A GraphQL type definition
-      # @param id [String] A client-provided to look up
-      # @param context [GraphQL::Query::Context] the current context
-      def object_from_id(type, id, context)
-        context.schema.object_from_id(id, context)
-      end
-
-      def load_application_object(arg_kwarg, id)
-        argument = @arguments_by_keyword[arg_kwarg]
-        lookup_as_type = @arguments_loads_as_type[arg_kwarg]
-        # See if any object can be found for this ID
-        loaded_application_object = object_from_id(lookup_as_type, id, context)
-        context.schema.after_lazy(loaded_application_object) do |application_object|
-          if application_object.nil?
-            err = LoadApplicationObjectFailedError.new(argument: argument, id: id, object: application_object)
-            load_application_object_failed(err)
-          end
-          # Double-check that the located object is actually of this type
-          # (Don't want to allow arbitrary access to objects this way)
-          resolved_application_object_type = context.schema.resolve_type(lookup_as_type, application_object, context)
-          context.schema.after_lazy(resolved_application_object_type) do |application_object_type|
-            possible_object_types = context.schema.possible_types(lookup_as_type)
-            if !possible_object_types.include?(application_object_type)
-              err = LoadApplicationObjectFailedError.new(argument: argument, id: id, object: application_object)
-              load_application_object_failed(err)
-            else
-              # This object was loaded successfully
-              # and resolved to the right type,
-              # now apply the `.authorized?` class method if there is one
-              if (class_based_type = application_object_type.metadata[:type_class])
-                context.schema.after_lazy(class_based_type.authorized?(application_object, context)) do |authed|
-                  if authed
-                    application_object
-                  else
-                    raise GraphQL::UnauthorizedError.new(
-                      object: application_object,
-                      type: class_based_type,
-                      context: context,
-                    )
-                  end
-                end
-              else
-                application_object
-              end
-            end
-          end
-        end
-      end
-
-      def load_application_object_failed(err)
-        raise err
-      end
-
       class << self
         # Default `:resolve` set below.
         # @return [Symbol] The method to call on instances of this object to resolve the field
@@ -327,36 +255,24 @@ module GraphQL
         # also add some preparation hook methods which will be used for this argument
         # @see {GraphQL::Schema::Argument#initialize} for the signature
         def argument(name, type, *rest, loads: nil, **kwargs, &block)
-          if loads
-            name_as_string = name.to_s
-
-            inferred_arg_name = case name_as_string
-            when /_id$/
-              name_as_string.sub(/_id$/, "").to_sym
-            when /_ids$/
-              name_as_string.sub(/_ids$/, "")
-                .sub(/([^s])$/, "\\1s")
-                .to_sym
-            else
-              name
-            end
-
-            kwargs[:as] ||= inferred_arg_name
-            own_arguments_loads_as_type[kwargs[:as]] = loads
-          end
+          arg_defn = super(*argument_with_loads(name, type, *rest, loads: loads, **kwargs, &block))
 
-          arg_defn = super(name, type, *rest, **kwargs, &block)
+          own_arguments_loads_as_type[arg_defn.keyword] = loads if loads
 
           if loads && arg_defn.type.list?
             class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def load_#{arg_defn.keyword}(values)
-              GraphQL::Execution::Lazy.all(values.map { |value| load_application_object(:#{arg_defn.keyword}, value) })
+              argument = @arguments_by_keyword[:#{arg_defn.keyword}]
+              lookup_as_type = @arguments_loads_as_type[:#{arg_defn.keyword}]
+              GraphQL::Execution::Lazy.all(values.map { |value| load_application_object(argument, lookup_as_type, value) })
             end
             RUBY
           elsif loads
             class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def load_#{arg_defn.keyword}(value)
-              load_application_object(:#{arg_defn.keyword}, value)
+              argument = @arguments_by_keyword[:#{arg_defn.keyword}]
+              lookup_as_type = @arguments_loads_as_type[:#{arg_defn.keyword}]
+              load_application_object(argument, lookup_as_type, value)
             end
             RUBY
           else

data/lib/graphql/static_validation/base_visitor.rb

@@ -145,6 +145,14 @@ module GraphQL
           @path.pop
         end
 
+        def on_input_object(node, parent)
+          is_list = @argument_definitions.last&.type&.list? == true
+
+          @path.push(parent.children.index(node)) if is_list
+          super
+          @path.pop if is_list
+        end
+
         # @return [GraphQL::BaseType] The current object type
         def type_definition
           @object_types.last

data/lib/graphql/subscriptions/action_cable_subscriptions.rb

@@ -46,7 +46,7 @@ module GraphQL
     #       # Track the subscription here so we can remove it
     #       # on unsubscribe.
     #       if result.context[:subscription_id]
-    #         @subscription_ids << context[:subscription_id]
+    #         @subscription_ids << result.context[:subscription_id]
     #       end
     #
     #       transmit(payload)

data/lib/graphql/tracing.rb

@@ -42,8 +42,8 @@ module GraphQL
   # execute_multiplex | `{ multiplex: GraphQL::Execution::Multiplex }`
   # execute_query | `{ query: GraphQL::Query }`
   # execute_query_lazy | `{ query: GraphQL::Query?, multiplex: GraphQL::Execution::Multiplex? }`
-  # execute_field | `{ context: GraphQL::Query::Context::FieldResolutionContext?, field: GraphQL::Schema::Field?, path: Array<String, Integer>?}`
-  # execute_field_lazy | `{ context: GraphQL::Query::Context::FieldResolutionContext?, field: GraphQL::Schema::Field?, path: Array<String, Integer>?}`
+  # execute_field | `{ context: GraphQL::Query::Context::FieldResolutionContext?, owner: Class?, field: GraphQL::Schema::Field?, path: Array<String, Integer>?}`
+  # execute_field_lazy | `{ context: GraphQL::Query::Context::FieldResolutionContext?, owner: Class?, field: GraphQL::Schema::Field?, path: Array<String, Integer>?}`
   #
   # Note that `execute_field` and `execute_field_lazy` receive different data in different settings:
   #

data/lib/graphql/tracing/data_dog_tracing.rb

@@ -21,6 +21,11 @@ module GraphQL
           if key == 'execute_multiplex'
             operations = data[:multiplex].queries.map(&:selected_operation_name).join(', ')
             span.resource = operations unless operations.empty?
+
+            # For top span of query, set the analytics sample rate tag, if available.
+            if analytics_enabled?
+              Datadog::Contrib::Analytics.set_sample_rate(span, analytics_sample_rate)
+            end
           end
 
           if key == 'execute_query'
@@ -41,6 +46,20 @@ module GraphQL
         options.fetch(:tracer, Datadog.tracer)
       end
 
+      def analytics_available?
+        defined?(Datadog::Contrib::Analytics) \
+          && Datadog::Contrib::Analytics.respond_to?(:enabled?) \
+          && Datadog::Contrib::Analytics.respond_to?(:set_sample_rate)
+      end
+
+      def analytics_enabled?
+        analytics_available? && Datadog::Contrib::Analytics.enabled?(options.fetch(:analytics_enabled, false))
+      end
+
+      def analytics_sample_rate
+        options.fetch(:analytics_sample_rate, 1.0)
+      end
+
       def platform_field_key(type, field)
         "#{type.graphql_name}.#{field.graphql_name}"
       end

data/lib/graphql/tracing/platform_tracing.rb

@@ -32,8 +32,9 @@ module GraphQL
             trace_field = true # implemented with instrumenter
           else
             field = data[:field]
+            owner = data[:owner]
             # Lots of duplicated work here, can this be done ahead of time?
-            platform_key = platform_field_key(field.owner, field)
+            platform_key = platform_field_key(owner, field)
             return_type = field.type.unwrap
             # Handle LateBoundTypes, which don't have `#kind`
             trace_field = if return_type.respond_to?(:kind) && (return_type.kind.scalar? || return_type.kind.enum?)

data/lib/graphql/types.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 require "graphql/types/boolean"
+require "graphql/types/big_int"
 require "graphql/types/float"
 require "graphql/types/id"
 require "graphql/types/int"

data/lib/graphql/types/big_int.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Types
+    class BigInt < GraphQL::Schema::Scalar
+      description "Represents non-fractional signed whole numeric values. Since the value may exceed the size of a 32-bit integer, it's encoded as a string."
+
+      def self.coerce_input(value, _ctx)
+        Integer(value)
+      rescue ArgumentError
+        nil
+      end
+
+      def self.coerce_result(value, _ctx)
+        value.to_i.to_s
+      end
+    end
+  end
+end

data/lib/graphql/types/int.rb

@@ -2,6 +2,7 @@
 
 module GraphQL
   module Types
+    # @see {Types::BigInt} for handling integers outside 32-bit range.
     class Int < GraphQL::Schema::Scalar
       description "Represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1."
 

data/lib/graphql/version.rb

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

data/spec/graphql/authorization_spec.rb

@@ -912,4 +912,30 @@ describe GraphQL::Authorization do
       assert_equal [{"message"=>"Unauthorized Query: nil"}], unauth_res["errors"]
     end
   end
+
+  describe "returning false" do
+    class FalseSchema < GraphQL::Schema
+      class Query < GraphQL::Schema::Object
+        def self.authorized?(obj, ctx)
+          false
+        end
+
+        field :int, Integer, null: false
+
+        def int
+          1
+        end
+      end
+      query(Query)
+      if TESTING_INTERPRETER
+        use GraphQL::Execution::Interpreter
+      end
+    end
+
+    it "works out-of-the-box" do
+      res = FalseSchema.execute("{ int }")
+      assert_nil res.fetch("data")
+      refute res.key?("errors")
+    end
+  end
 end

data/spec/graphql/language/visitor_spec.rb

@@ -161,8 +161,15 @@ describe GraphQL::Language::Visitor do
       end
 
       def on_argument(node, parent)
+        # https://github.com/rmosolgo/graphql-ruby/issues/2148
+        # Parent could become a random value, double check that it's a node
+        # to actually fail the test
+        raise RuntimeError, "Parent isn't a Node!" unless parent.class < GraphQL::Language::Nodes::AbstractNode
+
         if node.name == "deleteMe"
           super(DELETE_NODE, parent)
+        elsif node.name.include?("nope")
+          [1]
         else
           super
         end
@@ -351,6 +358,18 @@ GRAPHQL
       assert_equal after_query, new_document.to_query_string
     end
 
+    it "ignore non-Nodes::AbstractNode return values" do
+      query = <<-GRAPHQL.chop
+query {
+  doesntDoAnything(stillNothing: {nope: 1, alsoNope: 2, stillNope: 3})
+}
+GRAPHQL
+
+      document, new_document = get_result(query)
+      assert_equal query, document.to_query_string
+      assert_equal query, new_document.to_query_string
+    end
+
     it "can modify inline fragments" do
       before_query = <<-GRAPHQL.chop
 query {

data/spec/graphql/schema/argument_spec.rb

@@ -4,7 +4,7 @@ require "spec_helper"
 describe GraphQL::Schema::Argument do
   module SchemaArgumentTest
     class Query < GraphQL::Schema::Object
-      field :field, String, null: false do
+      field :field, String, null: true do
         argument :arg, String, description: "test", required: false
 
         argument :arg_with_block, String, required: false do
@@ -14,6 +14,11 @@ describe GraphQL::Schema::Argument do
         argument :aliased_arg, String, required: false, as: :renamed
         argument :prepared_arg, Int, required: false, prepare: :multiply
         argument :prepared_by_proc_arg, Int, required: false, prepare: ->(val, context) { context[:multiply_by] * val }
+        argument :exploding_prepared_arg, Int, required: false, prepare: ->(val, context) do
+          raise GraphQL::ExecutionError.new('boom!')
+        end
+
+        argument :keys, [String], required: false
 
         class Multiply
           def call(val, context)
@@ -41,6 +46,13 @@ describe GraphQL::Schema::Argument do
     end
   end
 
+  describe "#keys" do
+    it "is not overwritten by the 'keys' argument" do
+      expected_keys = ["aliasedArg", "arg", "argWithBlock", "explodingPreparedArg", "keys", "preparedArg", "preparedByCallableArg", "preparedByProcArg"]
+      assert_equal expected_keys, SchemaArgumentTest::Query.fields["field"].arguments.keys.sort
+    end
+  end
+
   describe "#path" do
     it "includes type, field and argument names" do
       assert_equal "Query.field.argWithBlock", SchemaArgumentTest::Query.fields["field"].arguments["argWithBlock"].path
@@ -105,6 +117,7 @@ describe GraphQL::Schema::Argument do
       # Make sure it's getting the renamed symbol:
       assert_equal '{:prepared_arg=>15}', res["data"]["field"]
     end
+
     it "calls the method on the provided Proc" do
       query_str = <<-GRAPHQL
       { field(preparedByProcArg: 5) }
@@ -114,6 +127,7 @@ describe GraphQL::Schema::Argument do
       # Make sure it's getting the renamed symbol:
       assert_equal '{:prepared_by_proc_arg=>15}', res["data"]["field"]
     end
+
     it "calls the method on the provided callable object" do
       query_str = <<-GRAPHQL
       { field(preparedByCallableArg: 5) }
@@ -123,5 +137,16 @@ describe GraphQL::Schema::Argument do
       # Make sure it's getting the renamed symbol:
       assert_equal '{:prepared_by_callable_arg=>15}', res["data"]["field"]
     end
+
+    it "handles exceptions raised by prepare" do
+      query_str = <<-GRAPHQL
+        { f1: field(arg: "echo"), f2: field(explodingPreparedArg: 5) }
+      GRAPHQL
+
+      res = SchemaArgumentTest::Schema.execute(query_str, context: {multiply_by: 3})
+      assert_equal({ 'f1' => '{:arg=>"echo"}', 'f2' => nil }, res['data'])
+      assert_equal(res['errors'][0]['message'], 'boom!')
+      assert_equal(res['errors'][0]['path'], ['f2'])
+    end
   end
 end

data/spec/graphql/schema/field_extension_spec.rb

@@ -9,6 +9,12 @@ describe GraphQL::Schema::FieldExtension do
       end
     end
 
+    class PowerOfFilter < GraphQL::Schema::FieldExtension
+      def after_resolve(object:, value:, arguments:, context:, memo:)
+        value**options.fetch(:power, 2)
+      end
+    end
+
     class MultiplyByOption < GraphQL::Schema::FieldExtension
       def after_resolve(object:, value:, arguments:, context:, memo:)
         value * options[:factor]
@@ -52,8 +58,13 @@ describe GraphQL::Schema::FieldExtension do
         argument :input, Integer, required: true
       end
 
-      def pass_thru(input:)
-        input # return it as-is, it will be modified by extensions
+      field :square, Integer, null: false, resolver_method: :pass_thru, extensions: [PowerOfFilter] do
+        argument :input, Integer, required: true
+      end
+
+      field :cube, Integer, null: false, resolver_method: :pass_thru do
+        extension(PowerOfFilter, power: 3)
+        argument :input, Integer, required: true
       end
 
       field :tripled_by_option, Integer, null: false, resolver_method: :pass_thru do
@@ -68,6 +79,10 @@ describe GraphQL::Schema::FieldExtension do
       field :multiply_input2, Integer, null: false, resolver_method: :pass_thru, extensions: [MultiplyByArgumentUsingResolve] do
         argument :input, Integer, required: true
       end
+
+      def pass_thru(input:, **args)
+        input # return it as-is, it will be modified by extensions
+      end
     end
 
     class Schema < GraphQL::Schema
@@ -107,6 +122,13 @@ describe GraphQL::Schema::FieldExtension do
       assert_equal 12, res["data"]["tripledByOption"]
     end
 
+    it "provides an empty hash as default options" do 
+      res = exec_query("{ square(input: 4) }")
+      assert_equal 16, res["data"]["square"]
+      res = exec_query("{ cube(input: 4) }")
+      assert_equal 64, res["data"]["cube"]
+    end
+
     it "can hide arguments from resolve methods" do
       res = exec_query("{ multiplyInput(input: 3, factor: 5) }")
       assert_equal 15, res["data"]["multiplyInput"]