graphql 1.10.5 → 1.10.6

data/lib/graphql/pagination/relation_connection.rb

@@ -12,7 +12,7 @@ module GraphQL
 
       def has_previous_page
         if @has_previous_page.nil?
-          @has_previous_page = if @after_offset && @after_offset > 0
+          @has_previous_page = if after_offset && after_offset > 0
             true
           elsif last
             # See whether there are any nodes _before_ the current offset.
@@ -29,7 +29,7 @@ module GraphQL
 
       def has_next_page
         if @has_next_page.nil?
-          @has_next_page = if @before_offset && @before_offset > 0
+          @has_next_page = if before_offset && before_offset > 0
             true
           elsif first
             relation_count(set_limit(sliced_nodes, first + 1)) == first + 1
@@ -105,33 +105,41 @@ module GraphQL
       def sliced_nodes
         @sliced_nodes ||= begin
           paginated_nodes = items
-          @after_offset = after && offset_from_cursor(after)
-          @before_offset = before && offset_from_cursor(before)
 
-          if @after_offset
+          if after_offset
             previous_offset = relation_offset(items) || 0
-            paginated_nodes = set_offset(paginated_nodes, previous_offset + @after_offset)
+            paginated_nodes = set_offset(paginated_nodes, previous_offset + after_offset)
           end
 
-          if @before_offset && @after_offset
-            if @after_offset < @before_offset
+          if before_offset && after_offset
+            if after_offset < before_offset
               # Get the number of items between the two cursors
-              space_between = @before_offset - @after_offset - 1
+              space_between = before_offset - after_offset - 1
               paginated_nodes = set_limit(paginated_nodes, space_between)
             else
               # TODO I think this is untested
               # The cursors overextend one another to an empty set
               paginated_nodes = null_relation(paginated_nodes)
             end
-          elsif @before_offset
+          elsif before_offset
             # Use limit to cut off the tail of the relation
-            paginated_nodes = set_limit(paginated_nodes, @before_offset - 1)
+            paginated_nodes = set_limit(paginated_nodes, before_offset - 1)
           end
 
           paginated_nodes
         end
       end
 
+      # @return [Integer, nil]
+      def before_offset
+        @before_offset ||= before && offset_from_cursor(before)
+      end
+
+      # @return [Integer, nil]
+      def after_offset
+        @after_offset ||= after && offset_from_cursor(after)
+      end
+
       # Apply `first` and `last` to `sliced_nodes`,
       # returning a new relation
       def limited_nodes

data/lib/graphql/query.rb

@@ -3,6 +3,7 @@ require "graphql/query/arguments"
 require "graphql/query/arguments_cache"
 require "graphql/query/context"
 require "graphql/query/executor"
+require "graphql/query/fingerprint"
 require "graphql/query/literal_input"
 require "graphql/query/null_context"
 require "graphql/query/result"
@@ -106,7 +107,7 @@ module GraphQL
       if variables.is_a?(String)
         raise ArgumentError, "Query variables should be a Hash, not a String. Try JSON.parse to prepare variables."
       else
-        @provided_variables = variables
+        @provided_variables = variables || {}
       end
 
       @query_string = query_string || query
@@ -265,6 +266,32 @@ module GraphQL
       }
     end
 
+    # This contains a few components:
+    #
+    # - The selected operation name (or `anonymous`)
+    # - The fingerprint of the query string
+    # - The number of given variables (for readability)
+    # - The fingerprint of the given variables
+    #
+    # This fingerprint can be used to track runs of the same operation-variables combination over time.
+    #
+    # @see operation_fingerprint
+    # @see variables_fingerprint
+    # @return [String] An opaque hash identifying this operation-variables combination
+    def fingerprint
+      @fingerprint ||= "#{operation_fingerprint}/#{variables_fingerprint}"
+    end
+
+    # @return [String] An opaque hash for identifying this query's given query string and selected operation
+    def operation_fingerprint
+      @operation_fingerprint ||= "#{selected_operation_name || "anonymous"}/#{Fingerprint.generate(query_string)}"
+    end
+
+    # @return [String] An opaque hash for identifying this query's given a variable values (not including defaults)
+    def variables_fingerprint
+      @variables_fingerprint ||= "#{provided_variables.size}/#{Fingerprint.generate(provided_variables.to_json)}"
+    end
+
     def validation_pipeline
       with_prepared_ast { @validation_pipeline }
     end

data/lib/graphql/query/arguments.rb

@@ -86,7 +86,8 @@ module GraphQL
         end
       end
 
-      def_delegators :to_h, :keys, :values, :each, :any?
+      def_delegators :to_h, :keys, :values, :each
+      def_delegators :@argument_values, :any?
 
       def prepare
         self

data/lib/graphql/query/fingerprint.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Query
+    # @api private
+    # @see Query#query_fingerprint
+    # @see Query#variables_fingerprint
+    # @see Query#fingerprint
+    module Fingerprint
+      # Make an obfuscated hash of the given string (either a query string or variables JSON)
+      # @param string [String]
+      # @return [String] A normalized, opaque hash
+      def self.generate(input_str)
+        # Implemented to be:
+        # - Short (and uniform) length
+        # - Stable
+        # - Irreversibly Opaque (don't want to leak variable values)
+        # - URL-friendly
+        bytes = Digest::SHA256.digest(input_str)
+        Base64.urlsafe_encode64(bytes)
+      end
+    end
+  end
+end

data/lib/graphql/rake_task.rb

@@ -76,15 +76,7 @@ module GraphQL
     # Set the parameters of this task by passing keyword arguments
     # or assigning attributes inside the block
     def initialize(options = {})
-      default_dependencies = if Rake::Task.task_defined?("environment")
-        [:environment]
-      else
-        []
-      end
-
-      all_options = DEFAULT_OPTIONS
-        .merge(dependencies: default_dependencies)
-        .merge(options)
+      all_options = DEFAULT_OPTIONS.merge(options)
       all_options.each do |k, v|
         self.public_send("#{k}=", v)
       end
@@ -117,18 +109,26 @@ module GraphQL
       File.join(@directory, @json_outfile)
     end
 
+    def load_rails_environment_if_defined
+      if Rake::Task.task_defined?('environment')
+        Rake::Task['environment'].invoke
+      end
+    end
+
     # Use the Rake DSL to add tasks
     def define_task
       namespace(@namespace) do
         namespace("schema") do
           desc("Dump the schema to IDL in #{idl_path}")
           task :idl => @dependencies do
+            load_rails_environment_if_defined
             write_outfile(:to_definition, idl_path)
             puts "Schema IDL dumped into #{idl_path}"
           end
 
           desc("Dump the schema to JSON in #{json_path}")
           task :json => @dependencies do
+            load_rails_environment_if_defined
             write_outfile(:to_json, json_path)
             puts "Schema JSON dumped into #{json_path}"
           end

data/lib/graphql/schema.rb

@@ -96,6 +96,67 @@ module GraphQL
       end
     end
 
+    module LazyHandlingMethods
+      # Call the given block at the right time, either:
+      # - Right away, if `value` is not registered with `lazy_resolve`
+      # - After resolving `value`, if it's registered with `lazy_resolve` (eg, `Promise`)
+      # @api private
+      def after_lazy(value)
+        if lazy?(value)
+          GraphQL::Execution::Lazy.new do
+            result = sync_lazy(value)
+            # The returned result might also be lazy, so check it, too
+            after_lazy(result) do |final_result|
+              yield(final_result) if block_given?
+            end
+          end
+        else
+          yield(value) if block_given?
+        end
+      end
+
+      # Override this method to handle lazy objects in a custom way.
+      # @param value [Object] an instance of a class registered with {.lazy_resolve}
+      # @return [Object] A GraphQL-ready (non-lazy) object
+      # @api private
+      def sync_lazy(value)
+        lazy_method = lazy_method_name(value)
+        if lazy_method
+          synced_value = value.public_send(lazy_method)
+          sync_lazy(synced_value)
+        else
+          value
+        end
+      end
+
+      # @return [Symbol, nil] The method name to lazily resolve `obj`, or nil if `obj`'s class wasn't registered wtih {#lazy_resolve}.
+      def lazy_method_name(obj)
+        lazy_methods.get(obj)
+      end
+
+      # @return [Boolean] True if this object should be lazily resolved
+      def lazy?(obj)
+        !!lazy_method_name(obj)
+      end
+
+      # Return a lazy if any of `maybe_lazies` are lazy,
+      # otherwise, call the block eagerly and return the result.
+      # @param maybe_lazies [Array]
+      # @api private
+      def after_any_lazies(maybe_lazies)
+        if maybe_lazies.any? { |l| lazy?(l) }
+          GraphQL::Execution::Lazy.all(maybe_lazies).then do |result|
+            yield
+          end
+        else
+          yield
+        end
+      end
+    end
+
+    include LazyHandlingMethods
+    extend LazyHandlingMethods
+
     accepts_definitions \
       :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
       :max_depth, :max_complexity, :default_max_page_size,
@@ -740,16 +801,6 @@ module GraphQL
     # Error that is raised when [#Schema#from_definition] is passed an invalid schema definition string.
     class InvalidDocumentError < Error; end;
 
-    # @return [Symbol, nil] The method name to lazily resolve `obj`, or nil if `obj`'s class wasn't registered wtih {#lazy_resolve}.
-    def lazy_method_name(obj)
-      @lazy_methods.get(obj)
-    end
-
-    # @return [Boolean] True if this object should be lazily resolved
-    def lazy?(obj)
-      !!lazy_method_name(obj)
-    end
-
     # Return the GraphQL IDL for the schema
     # @param context [Hash]
     # @param only [<#call(member, ctx)>]
@@ -1582,48 +1633,6 @@ module GraphQL
         end
       end
 
-      # Call the given block at the right time, either:
-      # - Right away, if `value` is not registered with `lazy_resolve`
-      # - After resolving `value`, if it's registered with `lazy_resolve` (eg, `Promise`)
-      # @api private
-      def after_lazy(value)
-        if lazy?(value)
-          GraphQL::Execution::Lazy.new do
-            result = sync_lazy(value)
-            # The returned result might also be lazy, so check it, too
-            after_lazy(result) do |final_result|
-              yield(final_result) if block_given?
-            end
-          end
-        else
-          yield(value) if block_given?
-        end
-      end
-
-      # Override this method to handle lazy objects in a custom way.
-      # @param value [Object] an instance of a class registered with {.lazy_resolve}
-      # @param ctx [GraphQL::Query::Context] the context for this query
-      # @return [Object] A GraphQL-ready (non-lazy) object
-      def sync_lazy(value)
-        lazy_method = lazy_method_name(value)
-        if lazy_method
-          synced_value = value.public_send(lazy_method)
-          sync_lazy(synced_value)
-        else
-          value
-        end
-      end
-
-      # @return [Symbol, nil] The method name to lazily resolve `obj`, or nil if `obj`'s class wasn't registered wtih {#lazy_resolve}.
-      def lazy_method_name(obj)
-        lazy_methods.get(obj)
-      end
-
-      # @return [Boolean] True if this object should be lazily resolved
-      def lazy?(obj)
-        !!lazy_method_name(obj)
-      end
-
       private
 
       def lazy_methods
@@ -1756,16 +1765,24 @@ module GraphQL
             }
             own_possible_types[owner.graphql_name] = owner.possible_types
           elsif type.kind.interface? && owner.kind.object?
-            new_interfaces = owner.interfaces.map do |t|
-              if t.is_a?(String) && t == type.graphql_name
-                type
-              elsif t.is_a?(LateBoundType) && t.graphql_name == type.graphql_name
-                type
+            new_interfaces = []
+            owner.interfaces.each do |int_t|
+              if int_t.is_a?(String) && int_t == type.graphql_name
+                new_interfaces << type
+              elsif int_t.is_a?(LateBoundType) && int_t.graphql_name == type.graphql_name
+                new_interfaces << type
               else
-                t
+                # Don't re-add proper interface definitions,
+                # they were probably already added, maybe with options.
               end
             end
             owner.implements(*new_interfaces)
+            new_interfaces.each do |int|
+              pt = own_possible_types[int.graphql_name] ||= []
+              if !pt.include?(owner)
+                pt << owner
+              end
+            end
           end
 
         when nil
@@ -1864,46 +1881,27 @@ module GraphQL
           end
           if type.kind.object?
             own_possible_types[type.graphql_name] = [type]
-            type.interfaces.each do |i|
-              implementers = own_possible_types[i.graphql_name] ||= []
-              implementers << type
-              add_type(i, owner: type, late_types: late_types, path: path + ["implements"])
+            type.interface_type_memberships.each do |interface_type_membership|
+              case interface_type_membership
+              when Schema::TypeMembership
+                interface_type = interface_type_membership.abstract_type
+                # We can get these now; we'll have to get late-bound types later
+                if interface_type.is_a?(Module)
+                  implementers = own_possible_types[interface_type.graphql_name] ||= []
+                  implementers << type
+                end
+              when String, Schema::LateBoundType
+                interface_type = interface_type_membership
+              else
+                raise ArgumentError, "Invariant: unexpected type membership for #{type.graphql_name}: #{interface_type_membership.class} (#{interface_type_membership.inspect})"
+              end
+              add_type(interface_type, owner: type, late_types: late_types, path: path + ["implements"])
             end
           end
         end
       end
     end
 
-    # Call the given block at the right time, either:
-    # - Right away, if `value` is not registered with `lazy_resolve`
-    # - After resolving `value`, if it's registered with `lazy_resolve` (eg, `Promise`)
-    # @api private
-    def after_lazy(value)
-      if lazy?(value)
-        GraphQL::Execution::Lazy.new do
-          result = sync_lazy(value)
-          # The returned result might also be lazy, so check it, too
-          after_lazy(result) do |final_result|
-            yield(final_result) if block_given?
-          end
-        end
-      else
-        yield(value) if block_given?
-      end
-    end
-
-    # @see Schema.sync_lazy for a hook to override
-    # @api private
-    def sync_lazy(value)
-      lazy_method = lazy_method_name(value)
-      if lazy_method
-        synced_value = value.public_send(lazy_method)
-        sync_lazy(synced_value)
-      else
-        value
-      end
-    end
-
     protected
 
     def rescues?

data/lib/graphql/schema/field.rb

@@ -173,7 +173,7 @@ module GraphQL
       # @param resolver_method [Symbol] The method on the type to call to resolve this field (defaults to `name`)
       # @param connection [Boolean] `true` if this field should get automagic connection behavior; default is to infer by `*Connection` in the return type name
       # @param connection_extension [Class] The extension to add, to implement connections. If `nil`, no extension is added.
-      # @param max_page_size [Integer] For connections, the maximum number of items to return from this field
+      # @param max_page_size [Integer, nil] For connections, the maximum number of items to return from this field, or `nil` to allow unlimited results.
       # @param introspection [Boolean] If true, this field will be marked as `#introspection?` and the name may begin with `__`
       # @param resolve [<#call(obj, args, ctx)>] **deprecated** for compatibility with <1.8.0
       # @param field [GraphQL::Field, GraphQL::Schema::Field] **deprecated** for compatibility with <1.8.0
@@ -188,7 +188,7 @@ module GraphQL
       # @param trace [Boolean] If true, a {GraphQL::Tracing} tracer will measure this scalar field
       # @param ast_node [Language::Nodes::FieldDefinition, nil] If this schema was parsed from definition, this AST node defined the field
       # @param method_conflict_warning [Boolean] If false, skip the warning if this field's method conflicts with a built-in method
-      def initialize(type: nil, name: nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, resolver_method: nil, resolve: nil, connection: nil, max_page_size: nil, scope: nil, introspection: false, camelize: true, trace: nil, complexity: 1, ast_node: nil, extras: [], extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, arguments: EMPTY_HASH, &definition_block)
+      def initialize(type: nil, name: nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, resolver_method: nil, resolve: nil, connection: nil, max_page_size: :not_given, scope: nil, introspection: false, camelize: true, trace: nil, complexity: 1, ast_node: nil, extras: [], extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, arguments: EMPTY_HASH, &definition_block)
         if name.nil?
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
         end
@@ -242,7 +242,8 @@ module GraphQL
         @return_type_expr = type
         @return_type_null = null
         @connection = connection
-        @max_page_size = max_page_size
+        @has_max_page_size = max_page_size != :not_given
+        @max_page_size = max_page_size == :not_given ? nil : max_page_size
         @introspection = introspection
         @extras = extras
         @resolver_class = resolver_class
@@ -381,7 +382,12 @@ module GraphQL
         end
       end
 
-      # @return [Integer, nil] Applied to connections if present
+      # @return [Boolean] True if this field's {#max_page_size} should override the schema default.
+      def has_max_page_size?
+        @has_max_page_size
+      end
+
+      # @return [Integer, nil] Applied to connections if {#has_max_page_size?}
       attr_reader :max_page_size
 
       # @return [GraphQL::Field]
@@ -646,22 +652,34 @@ module GraphQL
         if graphql_args.any? || @extras.any?
           # Splat the GraphQL::Arguments to Ruby keyword arguments
           ruby_kwargs = graphql_args.to_kwargs
+          maybe_lazies = []
           # Apply any `prepare` methods. Not great code organization, can this go somewhere better?
           arguments.each do |name, arg_defn|
             ruby_kwargs_key = arg_defn.keyword
 
-            loads = arg_defn.loads
-            if ruby_kwargs.key?(ruby_kwargs_key) && loads && !arg_defn.from_resolver?
+            if ruby_kwargs.key?(ruby_kwargs_key)
+              loads = arg_defn.loads
               value = ruby_kwargs[ruby_kwargs_key]
-              ruby_kwargs[ruby_kwargs_key] = if arg_defn.type.list?
-                value.map { |val| load_application_object(arg_defn, loads, val, field_ctx.query.context) }
+              loaded_value = if loads && !arg_defn.from_resolver?
+                if arg_defn.type.list?
+                  loaded_values = value.map { |val| load_application_object(arg_defn, loads, val, field_ctx.query.context) }
+                  maybe_lazies.concat(loaded_values)
+                else
+                  load_application_object(arg_defn, loads, value, field_ctx.query.context)
+                end
               else
-                load_application_object(arg_defn, loads, value, field_ctx.query.context)
+                value
               end
-            end
 
-            if ruby_kwargs.key?(ruby_kwargs_key) && arg_defn.prepare
-              ruby_kwargs[ruby_kwargs_key] = arg_defn.prepare_value(obj, ruby_kwargs[ruby_kwargs_key])
+              maybe_lazies << field_ctx.schema.after_lazy(loaded_value) do |loaded_value|
+                prepared_value = if arg_defn.prepare
+                  arg_defn.prepare_value(obj, loaded_value)
+                else
+                  loaded_value
+                end
+
+                ruby_kwargs[ruby_kwargs_key] = prepared_value
+              end
             end
           end
 
@@ -669,7 +687,9 @@ module GraphQL
             ruby_kwargs[extra_arg] = fetch_extra(extra_arg, field_ctx)
           end
 
-          ruby_kwargs
+          field_ctx.schema.after_any_lazies(maybe_lazies) do
+            ruby_kwargs
+          end
         else
           NO_ARGS
         end