graphql 1.12.8 → 1.12.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 10ea46e2edf136b445de343ee1a58dd98b0a6c5800ef31923d7d184198ed58fd
-  data.tar.gz: f2f6dff0bf020bfef04769deb3fd548317121f0e636d7a47a94baea862f341ac
+  metadata.gz: bcd53f90295f4a4444841bee25b0329ba993ea2ae3d10bb9ba807f262b9354ca
+  data.tar.gz: af7807ae411d7f50252758b64c2248fc3c640cc2930c22c0740bae25d567e7ef
 SHA512:
-  metadata.gz: a79fde55cedcd391b7dfe7c141e22c51563aeefceb0fda494dd50f4281fefb0104f8663e688395268c95361ee10e01c7bfb69250368441ec8b8c9ad0d00ac279
-  data.tar.gz: 49a7b0f5cdf9d3a64ff05b0898c7ef93c6cdfd210baf93affa25afe3f3d7b59187fe3e7727f467af9411a085c5f6e8e281fafd27352fe97128f98bd82ffde330
+  metadata.gz: 770c7bde4c17619f645d77829bb9ca78bed5f944a7609a31095d9e8e859adbf0728988a640ad98a3a10fbccc73f658a0906296d1d6bed5f0f6d77b53a9bf9c79
+  data.tar.gz: 9fee4b7cb3e63c07a702462c1b6ebc0a0bd2d1342a4d22803839b63a03d8a910ebd6189a748695ba75e2732e1af30e9a6b9587d72be602eee6b1db43822bb779

data/lib/generators/graphql/install_generator.rb

@@ -122,7 +122,7 @@ module Graphql
         if options.api?
           say("Skipped graphiql, as this rails project is API only")
           say("  You may wish to use GraphiQL.app for development: https://github.com/skevy/graphiql-app")
-        elsif !options[:skip_graphiql]
+        elsif !options[:skip_graphiql] && !File.read(Rails.root.join("Gemfile")).include?("graphiql-rails")
           gem("graphiql-rails", group: :development)
 
           # This is a little cheat just to get cleaner shell output:

data/lib/generators/graphql/templates/graphql_controller.erb

@@ -15,9 +15,9 @@ class GraphqlController < ApplicationController
     }
     result = <%= schema_name %>.execute(query, variables: variables, context: context, operation_name: operation_name)
     render json: result
-  rescue => e
+  rescue StandardError => e
     raise e unless Rails.env.development?
-    handle_error_in_development e
+    handle_error_in_development(e)
   end
 
   private

data/lib/graphql.rb

@@ -81,10 +81,19 @@ end
 # Order matters for these:
 
 require "graphql/execution_error"
+require "graphql/runtime_type_error"
+require "graphql/unresolved_type_error"
+require "graphql/invalid_null_error"
+require "graphql/analysis_error"
+require "graphql/coercion_error"
+require "graphql/invalid_name_error"
+require "graphql/integer_decoding_error"
+require "graphql/integer_encoding_error"
+require "graphql/string_encoding_error"
+
 require "graphql/define"
 require "graphql/base_type"
 require "graphql/object_type"
-
 require "graphql/enum_type"
 require "graphql/input_object_type"
 require "graphql/interface_type"
@@ -109,9 +118,6 @@ require "graphql/analysis"
 require "graphql/tracing"
 require "graphql/dig"
 require "graphql/execution"
-require "graphql/runtime_type_error"
-require "graphql/unresolved_type_error"
-require "graphql/invalid_null_error"
 require "graphql/pagination"
 require "graphql/schema"
 require "graphql/query"
@@ -133,12 +139,6 @@ require "graphql/static_validation"
 require "graphql/dataloader"
 require "graphql/introspection"
 
-require "graphql/analysis_error"
-require "graphql/coercion_error"
-require "graphql/invalid_name_error"
-require "graphql/integer_decoding_error"
-require "graphql/integer_encoding_error"
-require "graphql/string_encoding_error"
 require "graphql/version"
 require "graphql/compatibility"
 require "graphql/function"

data/lib/graphql/dataloader.rb

@@ -29,7 +29,12 @@ module GraphQL
 
     def initialize
       @source_cache = Hash.new { |h, source_class| h[source_class] = Hash.new { |h2, batch_parameters|
-          source = source_class.new(*batch_parameters)
+          source = if RUBY_VERSION < "3"
+            source_class.new(*batch_parameters)
+          else
+            batch_args, batch_kwargs = batch_parameters
+            source_class.new(*batch_args, **batch_kwargs)
+          end
           source.setup(self)
           h2[batch_parameters] = source
         }
@@ -43,8 +48,15 @@ module GraphQL
     # @param batch_parameters [Array<Object>]
     # @return [GraphQL::Dataloader::Source] An instance of {source_class}, initialized with `self, *batch_parameters`,
     #   and cached for the lifetime of this {Multiplex}.
-    def with(source_class, *batch_parameters)
-      @source_cache[source_class][batch_parameters]
+    if RUBY_VERSION < "3"
+      def with(source_class, *batch_parameters)
+        @source_cache[source_class][batch_parameters]
+      end
+    else
+      def with(source_class, *batch_args, **batch_kwargs)
+        batch_parameters = [batch_args, batch_kwargs]
+        @source_cache[source_class][batch_parameters]
+      end
     end
 
     # Tell the dataloader that this fiber is waiting for data.
@@ -104,7 +116,7 @@ module GraphQL
         while @pending_jobs.any?
           # Create a Fiber to consume jobs until one of the jobs yields
           # or jobs run out
-          f = Fiber.new {
+          f = spawn_fiber {
             while (job = @pending_jobs.shift)
               job.call
             end
@@ -191,7 +203,7 @@ module GraphQL
         #
         # This design could probably be improved by maintaining a `@pending_sources` queue which is shared by the fibers,
         # similar to `@pending_jobs`. That way, when a fiber is resumed, it would never pick up work that was finished by a different fiber.
-        source_fiber = Fiber.new do
+        source_fiber = spawn_fiber do
           pending_sources.each(&:run_pending_keys)
         end
       end
@@ -204,5 +216,24 @@ module GraphQL
     rescue UncaughtThrowError => e
       throw e.tag, e.value
     end
+
+    # Copies the thread local vars into the fiber thread local vars. Many
+    # gems (such as RequestStore, MiniRacer, etc.) rely on thread local vars
+    # to keep track of execution context, and without this they do not
+    # behave as expected.
+    #
+    # @see https://github.com/rmosolgo/graphql-ruby/issues/3449
+    def spawn_fiber
+      fiber_locals = {} 
+
+      Thread.current.keys.each do |fiber_var_key|
+        fiber_locals[fiber_var_key] = Thread.current[fiber_var_key]
+      end 
+
+      Fiber.new do 
+        fiber_locals.each { |k, v| Thread.current[k] = v }
+        yield
+      end 
+    end
   end
 end

data/lib/graphql/execution/interpreter/runtime.rb

@@ -50,7 +50,7 @@ module GraphQL
           root_type = schema.root_type_for_operation(root_op_type)
           path = []
           set_all_interpreter_context(query.root_value, nil, nil, path)
-          object_proxy = authorized_new(root_type, query.root_value, context, path)
+          object_proxy = authorized_new(root_type, query.root_value, context)
           object_proxy = schema.sync_lazy(object_proxy)
           if object_proxy.nil?
             # Root .authorized? returned false.
@@ -193,7 +193,7 @@ module GraphQL
           object = owner_object
 
           if is_introspection
-            object = authorized_new(field_defn.owner, object, context, next_path)
+            object = authorized_new(field_defn.owner, object, context)
           end
 
           total_args_count = field_defn.arguments.size
@@ -246,11 +246,17 @@ module GraphQL
                   # Use this flag to tell Interpreter::Arguments to add itself
                   # to the keyword args hash _before_ freezing everything.
                   extra_args[:argument_details] = :__arguments_add_self
+                when :irep_node
+                  # This is used by `__typename` in order to support the legacy runtime,
+                  # but it has no use here (and it's always `nil`).
+                  # Stop adding it here to avoid the overhead of `.merge_extras` below.
                 else
                   extra_args[extra] = field_defn.fetch_extra(extra, context)
                 end
               end
-              resolved_arguments = resolved_arguments.merge_extras(extra_args)
+              if extra_args.any?
+                resolved_arguments = resolved_arguments.merge_extras(extra_args)
+              end
               resolved_arguments.keyword_arguments
             end
 
@@ -372,7 +378,7 @@ module GraphQL
             end
           when "OBJECT"
             object_proxy = begin
-              authorized_new(current_type, value, context, path)
+              authorized_new(current_type, value, context)
             rescue GraphQL::ExecutionError => err
               err
             end
@@ -635,22 +641,8 @@ module GraphQL
           end
         end
 
-        def authorized_new(type, value, context, path)
-          trace_payload = { context: context, type: type, object: value, path: path }
-
-          auth_val = context.query.trace("authorized", trace_payload) do
-            type.authorized_new(value, context)
-          end
-
-          if context.schema.lazy?(auth_val)
-            GraphQL::Execution::Lazy.new do
-              context.query.trace("authorized_lazy", trace_payload) do
-                context.schema.sync_lazy(auth_val)
-              end
-            end
-          else
-            auth_val
-          end
+        def authorized_new(type, value, context)
+          type.authorized_new(value, context)
         end
       end
     end

data/lib/graphql/pagination/connections.rb

@@ -79,7 +79,7 @@ module GraphQL
           context: context,
           parent: parent,
           field: field,
-          max_page_size: field.max_page_size || context.schema.default_max_page_size,
+          max_page_size: field.has_max_page_size? ? field.max_page_size : context.schema.default_max_page_size,
           first: arguments[:first],
           after: arguments[:after],
           last: arguments[:last],

data/lib/graphql/schema.rb

@@ -355,23 +355,6 @@ module GraphQL
     # For forwards-compatibility with Schema classes
     alias :graphql_definition :itself
 
-    # Validate a query string according to this schema.
-    # @param string_or_document [String, GraphQL::Language::Nodes::Document]
-    # @return [Array<GraphQL::StaticValidation::Error >]
-    def validate(string_or_document, rules: nil, context: nil)
-      doc = if string_or_document.is_a?(String)
-        GraphQL.parse(string_or_document)
-      else
-        string_or_document
-      end
-      query = GraphQL::Query.new(self, document: doc, context: context)
-      validator_opts = { schema: self }
-      rules && (validator_opts[:rules] = rules)
-      validator = GraphQL::StaticValidation::Validator.new(**validator_opts)
-      res = validator.validate(query, timeout: validate_timeout)
-      res[:errors]
-    end
-
     def deprecated_define(**kwargs, &block)
       super
       ensure_defined
@@ -712,6 +695,7 @@ module GraphQL
     def_delegators :_schema_class, :unauthorized_object, :unauthorized_field, :inaccessible_fields
     def_delegators :_schema_class, :directive
     def_delegators :_schema_class, :error_handler
+    def_delegators :_schema_class, :validate
 
 
     # Given this schema member, find the class-based definition object
@@ -861,7 +845,6 @@ module GraphQL
       def_delegators :graphql_definition,
         # Execution
         :execution_strategy_for_operation,
-        :validate,
         # Configuration
         :metadata, :redefine,
         :id_from_object_proc, :object_from_id_proc,
@@ -1293,6 +1276,23 @@ module GraphQL
         end
       end
 
+      # Validate a query string according to this schema.
+      # @param string_or_document [String, GraphQL::Language::Nodes::Document]
+      # @return [Array<GraphQL::StaticValidation::Error >]
+      def validate(string_or_document, rules: nil, context: nil)
+        doc = if string_or_document.is_a?(String)
+          GraphQL.parse(string_or_document)
+        else
+          string_or_document
+        end
+        query = GraphQL::Query.new(self, document: doc, context: context)
+        validator_opts = { schema: self }
+        rules && (validator_opts[:rules] = rules)
+        validator = GraphQL::StaticValidation::Validator.new(**validator_opts)
+        res = validator.validate(query, timeout: validate_timeout)
+        res[:errors]
+      end
+
       attr_writer :max_complexity
 
       def max_complexity(max_complexity = nil)

data/lib/graphql/schema/input_object.rb

@@ -226,8 +226,8 @@ module GraphQL
         # It's funny to think of a _result_ of an input object.
         # This is used for rendering the default value in introspection responses.
         def coerce_result(value, ctx)
-          # Allow the application to provide values as :symbols, and convert them to the strings
-          value = value.reduce({}) { |memo, (k, v)| memo[k.to_s] = v; memo }
+          # Allow the application to provide values as :snake_symbols, and convert them to the camelStrings
+          value = value.reduce({}) { |memo, (k, v)| memo[Member::BuildType.camelize(k.to_s)] = v; memo }
 
           result = {}
 

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

@@ -113,27 +113,15 @@ module GraphQL
         end
 
         def visible?(context)
-          if @mutation
-            @mutation.visible?(context)
-          else
-            true
-          end
+          true
         end
 
         def accessible?(context)
-          if @mutation
-            @mutation.accessible?(context)
-          else
-            true
-          end
+          true
         end
 
         def authorized?(object, context)
-          if @mutation
-            @mutation.authorized?(object, context)
-          else
-            true
-          end
+          true
         end
       end
     end

data/lib/graphql/schema/object.rb

@@ -48,12 +48,26 @@ module GraphQL
         # @return [GraphQL::Schema::Object, GraphQL::Execution::Lazy]
         # @raise [GraphQL::UnauthorizedError] if the user-provided hook returns `false`
         def authorized_new(object, context)
-          auth_val = context.query.with_error_handling do
-            begin
-              authorized?(object, context)
-            rescue GraphQL::UnauthorizedError => err
-              context.schema.unauthorized_object(err)
+          trace_payload = { context: context, type: self, object: object, path: context[:current_path] }
+
+          maybe_lazy_auth_val = context.query.trace("authorized", trace_payload) do
+            context.query.with_error_handling do
+              begin
+                authorized?(object, context)
+              rescue GraphQL::UnauthorizedError => err
+                context.schema.unauthorized_object(err)
+              end
+            end
+          end
+
+          auth_val = if context.schema.lazy?(maybe_lazy_auth_val)
+            GraphQL::Execution::Lazy.new do
+              context.query.trace("authorized_lazy", trace_payload) do
+                context.schema.sync_lazy(maybe_lazy_auth_val)
+              end
             end
+          else
+            maybe_lazy_auth_val
           end
 
           context.schema.after_lazy(auth_val) do |is_authorized|

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

@@ -4,7 +4,7 @@ module GraphQL
     module DirectivesAreDefined
       def initialize(*)
         super
-        @directive_names = context.schema.directives.keys
+        @directive_names = context.warden.directives.map(&:graphql_name)
       end
 
       def on_directive(node, parent)

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

@@ -373,17 +373,26 @@ module GraphQL
       # In this context, `parents` represends the "self scope" of the field,
       # what types may be found at this point in the query.
       def mutually_exclusive?(parents1, parents2)
-        parents1.each do |type1|
-          parents2.each do |type2|
-            # If the types we're comparing are both different object types,
-            # they have to be mutually exclusive.
-            if type1 != type2 && type1.kind.object? && type2.kind.object?
-              return true
+        if parents1.empty? || parents2.empty?
+          false
+        elsif parents1.length == parents2.length
+          parents1.length.times.any? do |i|
+            type1 = parents1[i - 1]
+            type2 = parents2[i - 1]
+            if type1 == type2
+              # If the types we're comparing are the same type,
+              # then they aren't mutually exclusive
+              false
+            else
+              # Check if these two scopes have _any_ types in common.
+              possible_right_types = context.query.possible_types(type1)
+              possible_left_types = context.query.possible_types(type2)
+              (possible_right_types & possible_left_types).empty?
             end
           end
+        else
+          true
         end
-
-        false
       end
     end
   end

data/lib/graphql/subscriptions/action_cable_subscriptions.rb

@@ -34,12 +34,12 @@ module GraphQL
     #         channel: self,
     #       }
     #
-    #       result = MySchema.execute({
+    #       result = MySchema.execute(
     #         query: query,
     #         context: context,
     #         variables: variables,
     #         operation_name: operation_name
-    #       })
+    #       )
     #
     #       payload = {
     #         result: result.to_h,
@@ -146,14 +146,15 @@ module GraphQL
       def setup_stream(channel, initial_event)
         topic = initial_event.topic
         channel.stream_from(stream_event_name(initial_event), coder: @action_cable_coder) do |message|
-          object = @serializer.load(message)
           events_by_fingerprint = @events[topic]
+          object = nil
           events_by_fingerprint.each do |_fingerprint, events|
             if events.any? && events.first == initial_event
               # The fingerprint has told us that this response should be shared by all subscribers,
               # so just run it once, then deliver the result to every subscriber
               first_event = events.first
               first_subscription_id = first_event.context.fetch(:subscription_id)
+              object ||= @serializer.load(message)
               result = execute_update(first_subscription_id, first_event, object)
               # Having calculated the result _once_, send the same payload to all subscribers
               events.each do |event|

data/lib/graphql/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.12.8
+  version: 1.12.9
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-04-12 00:00:00.000000000 Z
+date: 2021-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips