graphql 1.9.6 → 1.9.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 8bc71e9155287bd634009a90a72adcc1e96c6e82
-  data.tar.gz: 3ce70233bd4420c72d2a4c7189d6a7c7edd5a75a
+SHA256:
+  metadata.gz: bc1010a9a70360cc6b3d6dcb13db9d35c207179686f503d01d5904c2655f9ae2
+  data.tar.gz: 510f939a5c9dd9b1a66610e7d526aa84e9ae2b494f76a9a07973aef0b24e6cde
 SHA512:
-  metadata.gz: 1c536685b8bbab3e649377e1ea8f30c5fd5757b7209ff488fe64b4bf8be0dc5b90c74ac877ae39de3149e8557387ef321299cdfd788de3ab2b0090136cb954e1
-  data.tar.gz: 990776aff9a606378d3a61f3d9064f1e9257a97dbb4e2e0194c0306d5dbeaa4961583262e42bd0957464d1b9ee06c6ecc18b380a7d9061f89f4f6dcb5136773f
+  metadata.gz: bebd9ccec78e0ba8e2d2a13d351a33e9a169261faf954bc50710f80c4ad6d555e495761681e0691213a9ed409b3057f77118f91e73e577fdd988759e4c7eb743
+  data.tar.gz: d458a432047fa847b775f8ff5558084eb2cc845a5277d4f47643483de5f9049d2b19c8c7831058c79b28bc962000d8f13c5201a7396169fa81bf080be8f12e18

data/lib/generators/graphql/install_generator.rb

@@ -13,6 +13,7 @@ module Graphql
     #   - graphql/
     #     - resolvers/
     #     - types/
+    #       - base_field.rb
     #       - base_enum.rb
     #       - base_input_object.rb
     #       - base_interface.rb
@@ -93,7 +94,7 @@ module Graphql
         create_dir("#{options[:directory]}/types")
         template("schema.erb", schema_file_path)
 
-        ["base_object", "base_enum", "base_input_object", "base_interface", "base_scalar", "base_union"].each do |base_type|
+        ["base_object", "base_field", "base_enum", "base_input_object", "base_interface", "base_scalar", "base_union"].each do |base_type|
           template("#{base_type}.erb", "#{options[:directory]}/types/#{base_type}.rb")
         end
 

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

@@ -0,0 +1,7 @@
+module Types
+  class BaseField < GraphQL::Schema::Field
+    def resolve_field(obj, args, ctx)
+      resolve(obj, args, ctx)
+    end
+  end
+end

data/lib/graphql/analysis/ast/visitor.rb

@@ -220,8 +220,11 @@ module GraphQL
 
         # @return [GraphQL::Argument, nil] The most-recently-entered GraphQL::Argument, if currently inside one
         def argument_definition
-          # Don't get the _last_ one because that's the current one.
-          # Get the second-to-last one, which is the parent of the current one.
+          @argument_definitions.last
+        end
+
+        # @return [GraphQL::Argument, nil] The previous GraphQL argument
+        def previous_argument_definition
           @argument_definitions[-2]
         end
 

data/lib/graphql/execution/multiplex.rb

@@ -175,7 +175,11 @@ module GraphQL
             schema = multiplex.schema
             multiplex_analyzers = schema.multiplex_analyzers
             if multiplex.max_complexity
-              multiplex_analyzers += [GraphQL::Analysis::MaxQueryComplexity.new(multiplex.max_complexity)]
+              multiplex_analyzers += if schema.using_ast_analysis?
+                [GraphQL::Analysis::AST::MaxQueryComplexity]
+              else
+                [GraphQL::Analysis::MaxQueryComplexity.new(multiplex.max_complexity)]
+              end
             end
 
             schema.analysis_engine.analyze_multiplex(multiplex, multiplex_analyzers)

data/lib/graphql/query.rb

@@ -44,7 +44,12 @@ module GraphQL
 
     # @return [GraphQL::Language::Nodes::Document]
     def document
-      with_prepared_ast { @document }
+      # It's ok if this hasn't been assigned yet
+      if @query_string || @document
+        with_prepared_ast { @document }
+      else
+        nil
+      end
     end
 
     def inspect

data/lib/graphql/relay/array_connection.rb

@@ -13,7 +13,7 @@ module GraphQL
           sliced_nodes.count > first
         elsif GraphQL::Relay::ConnectionType.bidirectional_pagination && before
           # The original array is longer than the `before` index
-          index_from_cursor(before) < nodes.length
+          index_from_cursor(before) < nodes.length + 1
         else
           false
         end

data/lib/graphql/schema.rb

@@ -11,6 +11,7 @@ require "graphql/schema/middleware_chain"
 require "graphql/schema/null_mask"
 require "graphql/schema/possible_types"
 require "graphql/schema/rescue_middleware"
+require "graphql/schema/timeout"
 require "graphql/schema/timeout_middleware"
 require "graphql/schema/traversal"
 require "graphql/schema/type_expression"
@@ -90,6 +91,7 @@ module GraphQL
       :object_from_id, :id_from_object,
       :default_mask,
       :cursor_encoder,
+      disable_introspection_entry_points: ->(schema) { schema.disable_introspection_entry_points = true },
       directives: ->(schema, directives) { schema.directives = directives.reduce({}) { |m, d| m[d.name] = d; m } },
       directive: ->(schema, directive) { schema.directives[directive.graphql_name] = directive },
       instrument: ->(schema, type, instrumenter, after_built_ins: false) {
@@ -110,6 +112,8 @@ module GraphQL
       rescue_from: ->(schema, err_class, &block) { schema.rescue_from(err_class, &block) },
       tracer: ->(schema, tracer) { schema.tracers.push(tracer) }
 
+    ensure_defined :introspection_system
+
     attr_accessor \
       :query, :mutation, :subscription,
       :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
@@ -140,6 +144,9 @@ module GraphQL
     # @return [Class] Instantiated for each query
     attr_accessor :context_class
 
+    # [Boolean] True if this object disables the introspection entry point fields
+    attr_accessor :disable_introspection_entry_points
+
     class << self
       attr_writer :default_execution_strategy
     end
@@ -186,6 +193,7 @@ module GraphQL
       @introspection_system = nil
       @interpreter = false
       @error_bubbling = false
+      @disable_introspection_entry_points = false
     end
 
     # @return [Boolean] True if using the new {GraphQL::Execution::Interpreter}
@@ -712,7 +720,8 @@ module GraphQL
         :subscriptions,
         :union_memberships,
         :get_field, :root_types, :references_to, :type_from_ast,
-        :possible_types
+        :possible_types,
+        :disable_introspection_entry_points=
 
       def graphql_definition
         @graphql_definition ||= to_graphql
@@ -737,6 +746,7 @@ module GraphQL
         schema_defn.max_depth = max_depth
         schema_defn.default_max_page_size = default_max_page_size
         schema_defn.orphan_types = orphan_types
+        schema_defn.disable_introspection_entry_points = @disable_introspection_entry_points
 
         prepped_dirs = {}
         directives.each { |k, v| prepped_dirs[k] = v.graphql_definition}
@@ -887,6 +897,10 @@ module GraphQL
         end
       end
 
+      def disable_introspection_entry_points
+        @disable_introspection_entry_points = true
+      end
+
       def orphan_types(*new_orphan_types)
         if new_orphan_types.any?
           @orphan_types = new_orphan_types.flatten

data/lib/graphql/schema/argument.rb

@@ -21,6 +21,9 @@ module GraphQL
       # @return [Symbol] This argument's name in Ruby keyword arguments
       attr_reader :keyword
 
+      # @return [Class, Module, nil] If this argument should load an application object, this is the type of object to load
+      attr_reader :loads
+
       # @param arg_name [Symbol]
       # @param type_expr
       # @param desc [String]
@@ -30,7 +33,7 @@ module GraphQL
       # @param as [Symbol] Override the keyword name when passed to a method
       # @param prepare [Symbol] A method to call to transform this argument's valuebefore sending it to field resolution
       # @param camelize [Boolean] if true, the name will be camelized when building the schema
-      def initialize(arg_name = nil, type_expr = nil, desc = nil, required:, type: nil, name: nil, description: nil, default_value: NO_DEFAULT, as: nil, camelize: true, prepare: nil, owner:, &definition_block)
+      def initialize(arg_name = nil, type_expr = nil, desc = nil, required:, type: nil, name: nil, loads: nil, description: nil, default_value: NO_DEFAULT, as: nil, camelize: true, prepare: nil, owner:, &definition_block)
         arg_name ||= name
         name_str = camelize ? Member::BuildType.camelize(arg_name.to_s) : arg_name.to_s
         @name = name_str.freeze
@@ -40,6 +43,7 @@ module GraphQL
         @default_value = default_value
         @owner = owner
         @as = as
+        @loads = loads
         @keyword = as || Schema::Member::BuildType.underscore(@name).to_sym
         @prepare = prepare
 

data/lib/graphql/schema/input_object.rb

@@ -21,6 +21,17 @@ module GraphQL
         self.class.arguments.each do |name, arg_defn|
           @arguments_by_keyword[arg_defn.keyword] = arg_defn
           ruby_kwargs_key = arg_defn.keyword
+          loads = arg_defn.loads
+
+          if @ruby_style_hash.key?(ruby_kwargs_key) && loads
+            value = @ruby_style_hash[ruby_kwargs_key]
+            @ruby_style_hash[ruby_kwargs_key] = if arg_defn.type.list?
+              GraphQL::Execution::Lazy.all(value.map { |val| load_application_object(arg_defn, loads, val) })
+            else
+              load_application_object(arg_defn, loads, value)
+            end
+          end
+
           if @ruby_style_hash.key?(ruby_kwargs_key) && arg_defn.prepare
             @ruby_style_hash[ruby_kwargs_key] = arg_defn.prepare_value(self, @ruby_style_hash[ruby_kwargs_key])
           end
@@ -42,6 +53,10 @@ module GraphQL
         end
       end
 
+      def to_hash
+        to_h
+      end
+
       def unwrap_value(value)
         case value
         when Array
@@ -83,20 +98,14 @@ module GraphQL
         # @return [Class<GraphQL::Arguments>]
         attr_accessor :arguments_class
 
-        def argument(name, type, *rest, loads: nil, **kwargs, &block)
-          argument_defn = super(*argument_with_loads(name, type, *rest, loads: loads, **kwargs, &block))
+        def argument(*args, **kwargs, &block)
+          # Translate `loads:` to `as:` if needed`
+          *args, kwargs = argument_with_loads(*args, **kwargs, &block)
+          argument_defn = super(*args, **kwargs, &block)
           # Add a method access
           method_name = argument_defn.keyword
           define_method(method_name) do
-            value = @ruby_style_hash[method_name]
-            argument = @arguments_by_keyword[method_name]
-            if loads && argument_defn.type.list?
-              GraphQL::Execution::Lazy.all(value.map { |val| load_application_object(argument, loads, val) })
-            elsif loads
-              load_application_object(argument, loads, value)
-            else
-              value
-            end
+            self[method_name]
           end
         end
 
@@ -122,4 +131,4 @@ module GraphQL
       end
     end
   end
-end
+end

data/lib/graphql/schema/introspection_system.rb

@@ -18,7 +18,12 @@ module GraphQL
         @input_value_type = load_constant(:InputValueType).to_graphql
         @type_kind_enum = load_constant(:TypeKindEnum).to_graphql
         @directive_location_enum = load_constant(:DirectiveLocationEnum).to_graphql
-        @entry_point_fields = get_fields_from_class(class_sym: :EntryPoints)
+        @entry_point_fields =
+          if schema.disable_introspection_entry_points
+            {}
+          else
+            get_fields_from_class(class_sym: :EntryPoints)
+          end
         @dynamic_fields = get_fields_from_class(class_sym: :DynamicFields)
       end
 

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

@@ -13,8 +13,10 @@ module GraphQL
           cls.include(ArgumentObjectLoader)
         end
 
-        def argument_with_loads(name, type, *rest, loads: nil, **kwargs)
+        def argument_with_loads(*args, **kwargs)
+          loads = kwargs[:loads]
           if loads
+            name = args[0]
             name_as_string = name.to_s
 
             inferred_arg_name = case name_as_string
@@ -31,7 +33,7 @@ module GraphQL
             kwargs[:as] ||= inferred_arg_name
           end
 
-          return [name, type, *rest, **kwargs]
+          return [*args, **kwargs]
         end
 
         # @see {GraphQL::Schema::Argument#initialize} for parameters

data/lib/graphql/schema/resolver.rb

@@ -255,8 +255,11 @@ 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)
-          arg_defn = super(*argument_with_loads(name, type, *rest, loads: loads, **kwargs, &block))
-
+          *args, kwargs = argument_with_loads(name, type, *rest, loads: loads, **kwargs, &block)
+          # Short-circuit the InputObject's own `loads:` implementation
+          # so that we can support `#load_{x}` methods below.
+          kwargs.delete(:loads)
+          arg_defn = super(*args, **kwargs)
           own_arguments_loads_as_type[arg_defn.keyword] = loads if loads
 
           if loads && arg_defn.type.list?
@@ -264,7 +267,9 @@ module GraphQL
             def load_#{arg_defn.keyword}(values)
               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) })
+              context.schema.after_lazy(values) do |values2|
+                GraphQL::Execution::Lazy.all(values2.map { |value| load_application_object(argument, lookup_as_type, value) })
+              end
             end
             RUBY
           elsif loads

data/lib/graphql/schema/subscription.rb

@@ -92,6 +92,28 @@ module GraphQL
       def unsubscribe
         raise UnsubscribedError
       end
+
+      # Call this method to provide a new subscription_scope; OR
+      # call it without an argument to get the subscription_scope
+      # @param new_scope [Symbol]
+      # @return [Symbol]
+      READING_SCOPE = ::Object.new
+      def self.subscription_scope(new_scope = READING_SCOPE)
+        if new_scope != READING_SCOPE
+          @subscription_scope = new_scope
+        elsif defined?(@subscription_scope)
+          @subscription_scope
+        else
+          find_inherited_method(:subscription_scope, nil)
+        end
+      end
+
+      # Overriding Resolver#field_options to include subscription_scope
+      def self.field_options
+        super.merge(
+          subscription_scope: subscription_scope
+        )
+      end
     end
   end
 end

data/lib/graphql/schema/timeout.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    # This plugin will stop resolving new fields after `max_seconds` have elapsed.
+    # After the time has passed, any remaining fields will be `nil`, with errors added
+    # to the `errors` key. Any already-resolved fields will be in the `data` key, so
+    # you'll get a partial response.
+    #
+    # You can subclass `GraphQL::Schema::Timeout` and override the `handle_timeout` method
+    # to provide custom logic when a timeout error occurs.
+    #
+    # Note that this will stop a query _in between_ field resolutions, but
+    # it doesn't interrupt long-running `resolve` functions. Be sure to use
+    # timeout options for external connections. For more info, see
+    # www.mikeperham.com/2015/05/08/timeout-rubys-most-dangerous-api/
+    #
+    # @example Stop resolving fields after 2 seconds
+    #   class MySchema < GraphQL::Schema
+    #     use GraphQL::Schema::Timeout, max_seconds: 2
+    #   end
+    #
+    # @example Notifying Bugsnag and logging a timeout
+    #   class MyTimeout < GraphQL::Schema::Timeout
+    #     def handle_timeout(error, query)
+    #        Rails.logger.warn("GraphQL Timeout: #{error.message}: #{query.query_string}")
+    #        Bugsnag.notify(error, {query_string: query.query_string})
+    #     end
+    #   end
+    #
+    #   class MySchema < GraphQL::Schema
+    #     use MyTimeout, max_seconds: 2
+    #   end
+    #
+    class Timeout
+      attr_reader :max_seconds
+
+      def self.use(schema, **options)
+        tracer = new(**options)
+        schema.tracer(tracer)
+      end
+
+      # @param max_seconds [Numeric] how many seconds the query should be allowed to resolve new fields
+      def initialize(max_seconds:)
+        @max_seconds = max_seconds
+      end
+
+      def trace(key, data)
+        case key
+        when 'execute_multiplex'
+          timeout_state = {
+            timeout_at: Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) + max_seconds * 1000,
+            timed_out: false
+          }
+
+          data.fetch(:multiplex).queries.each do |query|
+            query.context.namespace(self.class)[:state] = timeout_state
+          end
+
+          yield
+        when 'execute_field', 'execute_field_lazy'
+          query = data[:context] ? data.fetch(:context).query : data.fetch(:query)
+          timeout_state = query.context.namespace(self.class).fetch(:state)
+          if Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) > timeout_state.fetch(:timeout_at)
+            error = if data[:context]
+              context = data.fetch(:context)
+              GraphQL::Schema::Timeout::TimeoutError.new(context.parent_type, context.field)
+            else
+              field = data.fetch(:field)
+              GraphQL::Schema::Timeout::TimeoutError.new(field.owner, field)
+            end
+
+            # Only invoke the timeout callback for the first timeout
+            unless timeout_state[:timed_out]
+              timeout_state[:timed_out] = true
+              handle_timeout(error, query)
+            end
+
+            error
+          else
+            yield
+          end
+        else
+          yield
+        end
+      end
+
+      # Invoked when a query times out.
+      # @param error [GraphQL::Schema::Timeout::TimeoutError]
+      # @param query [GraphQL::Error]
+      def handle_timeout(error, query)
+        # override to do something interesting
+      end
+
+      # This error is raised when a query exceeds `max_seconds`.
+      # Since it's a child of {GraphQL::ExecutionError},
+      # its message will be added to the response's `errors` key.
+      #
+      # To raise an error that will stop query resolution, use a custom block
+      # to take this error and raise a new one which _doesn't_ descend from {GraphQL::ExecutionError},
+      # such as `RuntimeError`.
+      class TimeoutError < GraphQL::ExecutionError
+        def initialize(parent_type, field)
+          super("Timeout on #{parent_type.graphql_name}.#{field.graphql_name}")
+        end
+      end
+    end
+  end
+end