graphql 2.1.0 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 785d064bf9279c1c66291e629607bbfe14f33ea0a8ad3e22549d253116159f81
-  data.tar.gz: a66884908e066f99293c3171aa1856977ba01fde58dca3a65a978ef025de8f32
+  metadata.gz: 9997a74f471a1d4abbca1fe24f276db80bbad6f87b278a8083491ced64354906
+  data.tar.gz: 4265a7d1e76f784ad3df4739328fedfae1698e26dc4a1fee982971650e553c47
 SHA512:
-  metadata.gz: f27e18f66f871cde5a6aedfea89621e57014c02062736b55aa86ebc4f64bdec83de93dca83c4aaede60c321113f4099efeab362cc3d4a2047d725e5ec2e7d73b
-  data.tar.gz: 4071a8921d60279b5ffc3ba11bb653e07596a9a97c0bab783c6a183558ff632996431d365052c27ea571b0b0c3a6a267f3cc10d1d4eff202eec513fc469f094e
+  metadata.gz: 2b1c5bed0660b9c194814e889384b3a37a27967c1f808aff55e693431056729434a2556cf85e9dd4c184262f8ad1344fe86316c3ffa12afc2c87315d69773f04
+  data.tar.gz: 0b2c961d00651a479ce183e0c77d23d2090df85f46490aac53d724d0f657f9cfe1c49bda191feec4b3a90f1cf671cd55f0a6a97d0c79c20d567fc47e214f921d

data/lib/generators/graphql/install/templates/base_mutation.erb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Mutations
   class BaseMutation < GraphQL::Schema::RelayClassicMutation

data/lib/generators/graphql/install/templates/mutation_type.erb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Types
   class MutationType < Types::BaseObject

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Types
   class BaseArgument < GraphQL::Schema::Argument

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Types
   class BaseConnection < Types::BaseObject

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Types
   class BaseEdge < Types::BaseObject

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Types
   class BaseEnum < GraphQL::Schema::Enum

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Types
   class BaseField < GraphQL::Schema::Field

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Types
   class BaseInputObject < GraphQL::Schema::InputObject

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Types
   module BaseInterface

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Types
   class BaseObject < GraphQL::Schema::Object

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Types
   class BaseScalar < GraphQL::Schema::Scalar

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Types
   class BaseUnion < GraphQL::Schema::Union

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 class GraphqlController < ApplicationController
   # If accessing from outside this domain, nullify the session

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Loaders
   class <%= class_name %> < GraphQL::Batch::Loader

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Mutations
   class <%= class_name %> < BaseMutation

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Types
   module NodeType

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Types
   class QueryType < Types::BaseObject

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 class <%= schema_name %> < GraphQL::Schema
   query(Types::QueryType)

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

@@ -29,6 +29,13 @@ module GraphQL
           true
         end
 
+        # Analyzer hook to decide at analysis time whether analysis
+        # requires a visitor pass; can be disabled for precomputed results.
+        # @return [Boolean] If analysis requires visitation or not
+        def visit?
+          true
+        end
+
         # The result for this analyzer. Returning {GraphQL::AnalysisError} results
         # in a query error.
         # @return [Any] The analyzer result

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

@@ -5,12 +5,12 @@ module GraphQL
       # Depth first traversal through a query AST, calling AST analyzers
       # along the way.
       #
-      # The visitor is a special case of GraphQL::Language::Visitor, visiting
+      # The visitor is a special case of GraphQL::Language::StaticVisitor, visiting
       # only the selected operation, providing helpers for common use cases such
       # as skipped fields and visiting fragment spreads.
       #
       # @see {GraphQL::Analysis::AST::Analyzer} AST Analyzers for queries
-      class Visitor < GraphQL::Language::Visitor
+      class Visitor < GraphQL::Language::StaticVisitor
         def initialize(query:, analyzers:)
           @analyzers = analyzers
           @path = []

data/lib/graphql/analysis/ast.rb

@@ -51,22 +51,26 @@ module GraphQL
         query.current_trace.analyze_query(query: query) do
           query_analyzers = analyzers
             .map { |analyzer| analyzer.new(query) }
-            .select { |analyzer| analyzer.analyze? }
+            .tap { _1.select!(&:analyze?) }
 
           analyzers_to_run = query_analyzers + multiplex_analyzers
           if analyzers_to_run.any?
-            visitor = GraphQL::Analysis::AST::Visitor.new(
-              query: query,
-              analyzers: analyzers_to_run
-            )
 
-            visitor.visit
+            analyzers_to_run.select!(&:visit?)
+            if analyzers_to_run.any?
+              visitor = GraphQL::Analysis::AST::Visitor.new(
+                query: query,
+                analyzers: analyzers_to_run
+              )
 
-            if visitor.rescued_errors.any?
-              visitor.rescued_errors
-            else
-              query_analyzers.map(&:result)
+              visitor.visit
+
+              if visitor.rescued_errors.any?
+                return visitor.rescued_errors
+              end
             end
+
+            query_analyzers.map(&:result)
           else
             []
           end
@@ -74,7 +78,7 @@ module GraphQL
       end
 
       def analysis_errors(results)
-        results.flatten.select { |r| r.is_a?(GraphQL::AnalysisError) }
+        results.flatten.tap { _1.select! { |r| r.is_a?(GraphQL::AnalysisError) } }
       end
     end
   end

data/lib/graphql/dataloader/source.rb

@@ -161,6 +161,13 @@ module GraphQL
         [*batch_args, **batch_kwargs]
       end
 
+      # Clear any already-loaded objects for this source
+      # @return [void]
+      def clear_cache
+        @results.clear
+        nil
+      end
+
       attr_reader :pending
 
       private

data/lib/graphql/dataloader.rb

@@ -104,6 +104,15 @@ module GraphQL
       nil
     end
 
+    # Clear any already-loaded objects from {Source} caches
+    # @return [void]
+    def clear_cache
+      @source_cache.each do |_source_class, batched_sources|
+        batched_sources.each_value(&:clear_cache)
+      end
+      nil
+    end
+
     # Use a self-contained queue for the work in the block.
     def run_isolated
       prev_queue = @pending_jobs

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

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Execution
+    class Interpreter
+      class Runtime
+        module GraphQLResult
+          def initialize(result_name, parent_result, is_non_null_in_parent)
+            @graphql_parent = parent_result
+            if parent_result && parent_result.graphql_dead
+              @graphql_dead = true
+            end
+            @graphql_result_name = result_name
+            @graphql_is_non_null_in_parent = is_non_null_in_parent
+            # Jump through some hoops to avoid creating this duplicate storage if at all possible.
+            @graphql_metadata = nil
+          end
+
+          def path
+            @path ||= build_path([])
+          end
+
+          def build_path(path_array)
+            graphql_result_name && path_array.unshift(graphql_result_name)
+            @graphql_parent ? @graphql_parent.build_path(path_array) : path_array
+          end
+
+          attr_accessor :graphql_dead
+          attr_reader :graphql_parent, :graphql_result_name, :graphql_is_non_null_in_parent
+
+          # @return [Hash] Plain-Ruby result data (`@graphql_metadata` contains Result wrapper objects)
+          attr_accessor :graphql_result_data
+        end
+
+        class GraphQLResultHash
+          def initialize(_result_name, _parent_result, _is_non_null_in_parent)
+            super
+            @graphql_result_data = {}
+          end
+
+          include GraphQLResult
+
+          attr_accessor :graphql_merged_into
+
+          def set_leaf(key, value)
+            # This is a hack.
+            # Basically, this object is merged into the root-level result at some point.
+            # But the problem is, some lazies are created whose closures retain reference to _this_
+            # object. When those lazies are resolved, they cause an update to this object.
+            #
+            # In order to return a proper top-level result, we have to update that top-level result object.
+            # In order to return a proper partial result (eg, for a directive), we have to update this object, too.
+            # Yowza.
+            if (t = @graphql_merged_into)
+              t.set_leaf(key, value)
+            end
+
+            @graphql_result_data[key] = value
+            # keep this up-to-date if it's been initialized
+            @graphql_metadata && @graphql_metadata[key] = value
+
+            value
+          end
+
+          def set_child_result(key, value)
+            if (t = @graphql_merged_into)
+              t.set_child_result(key, value)
+            end
+            @graphql_result_data[key] = value.graphql_result_data
+            # If we encounter some part of this response that requires metadata tracking,
+            # then create the metadata hash if necessary. It will be kept up-to-date after this.
+            (@graphql_metadata ||= @graphql_result_data.dup)[key] = value
+            value
+          end
+
+          def delete(key)
+            @graphql_metadata && @graphql_metadata.delete(key)
+            @graphql_result_data.delete(key)
+          end
+
+          def each
+            (@graphql_metadata || @graphql_result_data).each { |k, v| yield(k, v) }
+          end
+
+          def values
+            (@graphql_metadata || @graphql_result_data).values
+          end
+
+          def key?(k)
+            @graphql_result_data.key?(k)
+          end
+
+          def [](k)
+            (@graphql_metadata || @graphql_result_data)[k]
+          end
+
+          def merge_into(into_result)
+            self.each do |key, value|
+              case value
+              when GraphQLResultHash
+                next_into = into_result[key]
+                if next_into
+                  value.merge_into(next_into)
+                else
+                  into_result.set_child_result(key, value)
+                end
+              when GraphQLResultArray
+                # There's no special handling of arrays because currently, there's no way to split the execution
+                # of a list over several concurrent flows.
+                next_result.set_child_result(key, value)
+              else
+                # We have to assume that, since this passed the `fields_will_merge` selection,
+                # that the old and new values are the same.
+                into_result.set_leaf(key, value)
+              end
+            end
+            @graphql_merged_into = into_result
+          end
+        end
+
+        class GraphQLResultArray
+          include GraphQLResult
+
+          def initialize(_result_name, _parent_result, _is_non_null_in_parent)
+            super
+            @graphql_result_data = []
+          end
+
+          def graphql_skip_at(index)
+            # Mark this index as dead. It's tricky because some indices may already be storing
+            # `Lazy`s. So the runtime is still holding indexes _before_ skipping,
+            # this object has to coordinate incoming writes to account for any already-skipped indices.
+            @skip_indices ||= []
+            @skip_indices << index
+            offset_by = @skip_indices.count { |skipped_idx| skipped_idx < index}
+            delete_at_index = index - offset_by
+            @graphql_metadata && @graphql_metadata.delete_at(delete_at_index)
+            @graphql_result_data.delete_at(delete_at_index)
+          end
+
+          def set_leaf(idx, value)
+            if @skip_indices
+              offset_by = @skip_indices.count { |skipped_idx| skipped_idx < idx }
+              idx -= offset_by
+            end
+            @graphql_result_data[idx] = value
+            @graphql_metadata && @graphql_metadata[idx] = value
+            value
+          end
+
+          def set_child_result(idx, value)
+            if @skip_indices
+              offset_by = @skip_indices.count { |skipped_idx| skipped_idx < idx }
+              idx -= offset_by
+            end
+            @graphql_result_data[idx] = value.graphql_result_data
+            # If we encounter some part of this response that requires metadata tracking,
+            # then create the metadata hash if necessary. It will be kept up-to-date after this.
+            (@graphql_metadata ||= @graphql_result_data.dup)[idx] = value
+            value
+          end
+
+          def values
+            (@graphql_metadata || @graphql_result_data)
+          end
+        end
+      end
+    end
+  end
+end