graphql-fragment_cache 1.10.0 → 1.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c0987cb1e081b19356cfd389164150d7678c2fff2a479986f56e157ac485e79
-  data.tar.gz: 72cc6cf9a79c003be0c83dc60447840128ba1d8395e60171ce26a5eaf8190f2b
+  metadata.gz: af4f8899ace77b66aaabd9af9292de07a40d2384ef8db4a24394e75bdd4be78d
+  data.tar.gz: 21b141a16d460b4d1b8b6cf1146e54898a87c45b4f670aa0ab6cbaac78dc48d3
 SHA512:
-  metadata.gz: 78be339e321b1c76066e63960d615d85fc286531ba663eef4af3c62baee8b3d598867047cf1c52ca6085b7fca3cbd86ec0038718548e014aff5c8273740a3c9a
-  data.tar.gz: 005efd512fba6e4f91ba5aec08637ce058217f7c2e580ef4afa8c6323fef035a70c72a5abd74d418892f02b607b6e5fff288adfb9830ee9125985b852153775e
+  metadata.gz: 6af77b269f6712c5c39983a796c0f109d6098297de2ad2c2fd87b5f4b8c0e53f9b71d14a2d6e7d8eb0ec1f03c55f43f84f766cdc4663bcf0cd8c7c1148fef506
+  data.tar.gz: e396f56ee9182d1147662fb484264ead58ea34efb867a9c6be9d1d018b94f9fb69089b981cb510c693ecd142a9c1fc20280d34c26bab71d9dc40af45d471944b

data/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## master
 
+## 1.13.0 (2022-09-12)
+
+- [PR#83](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/83) Update Lookahead usage to support graphql-2.0.14 ([@DmitryTsepelev][])
+
+## 1.12.0 (2022-08-05)
+
+- [PR#70](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/70), [PR#82](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/82) Add #read_multi for fragments ([@daukadolt][], [@frostmark][])
+
+## 1.11.0 (2022-02-26)
+
+- [PR#79](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/79) Support graphql-ruby 2.0.0 ([@DmitryTsepelev][])
+
 ## 1.10.0 (2022-01-30)
 
 - [PR#77](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/77) Drop Ruby 2.5 support, add Ruby 3.0 ([@DmitryTsepelev][])
@@ -124,3 +136,5 @@
 [@bbugh]: https://github.com/bbugh
 [@jeromedalbert]: https://github.com/jeromedalbert
 [@mretzak]: https://github.com/mretzak
+[@daukadolt]: https://github.com/daukadolt
+[@frostmark]: https://github.com/frostmark

data/README.md

@@ -17,13 +17,10 @@ end
 
 ## Getting started
 
-Add the gem to your Gemfile `gem 'graphql-fragment_cache'` and add the plugin to your schema class (make sure to turn interpreter mode on with AST analysis!):
+Add the gem to your Gemfile `gem 'graphql-fragment_cache'` and add the plugin to your schema class:
 
 ```ruby
 class GraphqSchema < GraphQL::Schema
-  use GraphQL::Execution::Interpreter
-  use GraphQL::Analysis::AST
-
   use GraphQL::FragmentCache
 
   query QueryType
@@ -69,15 +66,6 @@ class QueryType < BaseObject
 end
 ```
 
-If you use [connections](https://graphql-ruby.org/pagination/connection_concepts.html) and plan to cache them—please turn on [brand new](https://github.com/rmosolgo/graphql-ruby/blob/master/lib/graphql/pagination/connections.rb#L5) connections hierarchy in your schema:
-
-```ruby
-class GraphqSchema < GraphQL::Schema
-  # ...
-  use GraphQL::Pagination::Connections
-end
-```
-
 ## Cache key generation
 
 Cache keys consist of the following parts: namespace, implicit key, and explicit key.

data/lib/.rbnext/2.3/graphql/fragment_cache/cache_key_builder.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require "json"
+require "digest"
+
+using RubyNext
+
+module GraphQL
+  module FragmentCache
+    using Ext
+
+    using(Module.new {
+      refine Array do
+        def traverse_argument(argument)
+          return argument unless argument.is_a?(GraphQL::Schema::InputObject)
+
+          "{#{argument.map { |_1, _2| "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")}}"
+        end
+
+        def to_selections_key
+          map { |val|
+            children = val.selections.empty? ? "" : "[#{val.selections.to_selections_key}]"
+
+            field_name = val.field.name
+            field_alias = val.ast_nodes.map(&:alias).join
+            field_name = "#{field_alias}:#{field_name}" unless field_alias.empty?
+
+            unless val.arguments.empty?
+              args = val.arguments.map { |_1, _2| "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")
+              field_name += "(#{args})"
+            end
+
+            "#{field_name}#{children}"
+          }.join(".")
+        end
+      end
+
+      refine ::GraphQL::Language::Nodes::AbstractNode do
+        def alias?(_)
+          false
+        end
+      end
+
+      refine ::GraphQL::Language::Nodes::Field do
+        def alias?(val)
+          self.alias == val
+        end
+      end
+
+      refine ::GraphQL::Execution::Lookahead do
+        def selection_with_alias(name, **kwargs)
+          return selection(name, **kwargs) if selects?(name, **kwargs)
+          alias_selection(name, **kwargs)
+        end
+
+        def alias_selection(name, selected_type: @selected_type, arguments: nil)
+          return alias_selections[name] if alias_selections.key?(name)
+
+          alias_node = lookup_alias_node(ast_nodes, name)
+          return ::GraphQL::Execution::Lookahead::NULL_LOOKAHEAD unless alias_node
+
+          next_field_name = alias_node.name
+
+          # From https://github.com/rmosolgo/graphql-ruby/blob/1a9a20f3da629e63ea8e5ee8400be82218f9edc3/lib/graphql/execution/lookahead.rb#L91
+          next_field_defn =
+            if GraphQL::FragmentCache.graphql_ruby_before_2_0?
+              get_class_based_field(selected_type, next_field_name)
+            else
+              @query.get_field(selected_type, next_field_name)
+            end
+
+          alias_selections[name] =
+            if next_field_defn
+              next_nodes = []
+              arguments = @query.arguments_for(alias_node, next_field_defn)
+              arguments = arguments.is_a?(::GraphQL::Execution::Interpreter::Arguments) ? arguments.keyword_arguments : arguments
+              @ast_nodes.each do |ast_node|
+                ast_node.selections.each do |selection|
+                  if GraphQL::FragmentCache.graphql_ruby_after_2_0_13?
+                    find_selected_nodes(selection, next_field_defn, arguments: arguments, matches: next_nodes)
+                  else
+                    find_selected_nodes(selection, next_field_name, next_field_defn, arguments: arguments, matches: next_nodes)
+                  end
+                end
+              end
+
+              if next_nodes.any?
+                ::GraphQL::Execution::Lookahead.new(query: @query, ast_nodes: next_nodes, field: next_field_defn, owner_type: selected_type)
+              else
+                ::GraphQL::Execution::Lookahead::NULL_LOOKAHEAD
+              end
+            else
+              ::GraphQL::Execution::Lookahead::NULL_LOOKAHEAD
+            end
+        end
+
+        def alias_selections
+          return @alias_selections if defined?(@alias_selections)
+          @alias_selections ||= {}
+        end
+
+        def lookup_alias_node(nodes, name)
+          return if nodes.empty?
+
+          nodes.find do |node|
+            if node.is_a?(GraphQL::Language::Nodes::FragmentSpread)
+              node = @query.fragments[node.name]
+              raise("Invariant: Can't look ahead to nonexistent fragment #{node.name} (found: #{@query.fragments.keys})") unless node
+            end
+
+            return node if node.alias?(name)
+            child = lookup_alias_node(node.children, name)
+            return child if child
+          end
+        end
+      end
+    })
+
+    # Builds cache key for fragment
+    class CacheKeyBuilder
+      using RubyNext
+
+      class << self
+        def call(**options)
+          new(**options).build
+        end
+      end
+
+      attr_reader :query, :path, :object, :schema
+
+      def initialize(object: nil, query:, path:, **options)
+        @object = object
+        @query = query
+        @schema = query.schema
+        @path = path
+        @options = options
+      end
+
+      def build
+        [
+          GraphQL::FragmentCache.namespace,
+          implicit_cache_key,
+          object_cache_key
+        ].compact.join("/")
+      end
+
+      private
+
+      def implicit_cache_key
+        Digest::SHA1.hexdigest("#{schema_cache_key}/#{query_cache_key}")
+      end
+
+      def schema_cache_key
+        @options.fetch(:schema_cache_key) { schema.schema_cache_key }
+      end
+
+      def query_cache_key
+        @options.fetch(:query_cache_key) { "#{path_cache_key}[#{selections_cache_key}]" }
+      end
+
+      def selections_cache_key
+        current_root =
+          path.reduce(query.lookahead) { |lkhd, field_name|
+            # Handle cached fields inside collections:
+            next lkhd if field_name.is_a?(Integer)
+
+            lkhd.selection_with_alias(field_name)
+          }
+
+        current_root.selections.to_selections_key
+      end
+
+      def path_cache_key
+        @options.fetch(:path_cache_key) do
+          lookahead = query.lookahead
+
+          path.map { |field_name|
+            # Handle cached fields inside collections:
+            next field_name if field_name.is_a?(Integer)
+
+            lookahead = lookahead.selection_with_alias(field_name)
+            raise "Failed to look ahead the field: #{field_name}" if lookahead.is_a?(::GraphQL::Execution::Lookahead::NullLookahead)
+
+            next lookahead.field.name if lookahead.arguments.empty?
+
+            args = lookahead.arguments.map { |_1, _2| "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")
+            "#{lookahead.field.name}(#{args})"
+          }.join("/")
+        end
+      end
+
+      def traverse_argument(argument)
+        return argument unless argument.is_a?(GraphQL::Schema::InputObject)
+
+        "{#{argument.map { |_1, _2| "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")}}"
+      end
+
+      def object_cache_key
+        @options[:object_cache_key] || object_key(object)
+      end
+
+      def object_key(obj)
+        ((!obj.nil?) || nil) && obj._graphql_cache_key
+      end
+    end
+  end
+end

data/lib/.rbnext/2.3/graphql/fragment_cache/memory_store.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+using RubyNext
+
+module GraphQL
+  module FragmentCache
+    # Memory adapter for storing cached fragments
+    class MemoryStore
+      using RubyNext
+
+      class Entry < Struct.new(:value, :expires_at, keyword_init: true)
+        def expired?
+          expires_at && expires_at < Time.now
+        end
+      end
+
+      attr_reader :default_expires_in
+
+      def initialize(expires_in: nil, **other)
+        raise ArgumentError, "Unsupported options: #{other.keys.join(",")}" unless other.empty?
+
+        @default_expires_in = expires_in
+        @storage = {}
+      end
+
+      def keys
+        storage.keys
+      end
+
+      def exist?(key)
+        storage.key?(key)
+      end
+
+      def read(key)
+        key = key.to_s
+        ((!storage[key].nil?) || nil) && storage[key].then do |entry|
+  if entry.expired?
+    delete(key)
+    next
+  end
+  entry.value
+end
+      end
+
+      def write(key, value, expires_in: default_expires_in, **options)
+        key = key.to_s
+        @storage[key] = Entry.new(value: value, expires_at: expires_in ? Time.now + expires_in : nil)
+      end
+
+      def delete(key)
+        key = key.to_s
+        storage.delete(key)
+      end
+
+      def clear
+        storage.clear
+      end
+
+      private
+
+      attr_reader :storage
+    end
+  end
+end

data/lib/.rbnext/2.7/graphql/fragment_cache/cache_key_builder.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require "json"
+require "digest"
+
+using RubyNext
+
+module GraphQL
+  module FragmentCache
+    using Ext
+
+    using(Module.new {
+      refine Array do
+        def traverse_argument(argument)
+          return argument unless argument.is_a?(GraphQL::Schema::InputObject)
+
+          "{#{argument.map { |_1, _2| "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")}}"
+        end
+
+        def to_selections_key
+          map { |val|
+            children = val.selections.empty? ? "" : "[#{val.selections.to_selections_key}]"
+
+            field_name = val.field.name
+            field_alias = val.ast_nodes.map(&:alias).join
+            field_name = "#{field_alias}:#{field_name}" unless field_alias.empty?
+
+            unless val.arguments.empty?
+              args = val.arguments.map { |_1, _2| "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")
+              field_name += "(#{args})"
+            end
+
+            "#{field_name}#{children}"
+          }.join(".")
+        end
+      end
+
+      refine ::GraphQL::Language::Nodes::AbstractNode do
+        def alias?(_)
+          false
+        end
+      end
+
+      refine ::GraphQL::Language::Nodes::Field do
+        def alias?(val)
+          self.alias == val
+        end
+      end
+
+      refine ::GraphQL::Execution::Lookahead do
+        def selection_with_alias(name, **kwargs)
+          return selection(name, **kwargs) if selects?(name, **kwargs)
+          alias_selection(name, **kwargs)
+        end
+
+        def alias_selection(name, selected_type: @selected_type, arguments: nil)
+          return alias_selections[name] if alias_selections.key?(name)
+
+          alias_node = lookup_alias_node(ast_nodes, name)
+          return ::GraphQL::Execution::Lookahead::NULL_LOOKAHEAD unless alias_node
+
+          next_field_name = alias_node.name
+
+          # From https://github.com/rmosolgo/graphql-ruby/blob/1a9a20f3da629e63ea8e5ee8400be82218f9edc3/lib/graphql/execution/lookahead.rb#L91
+          next_field_defn =
+            if GraphQL::FragmentCache.graphql_ruby_before_2_0?
+              get_class_based_field(selected_type, next_field_name)
+            else
+              @query.get_field(selected_type, next_field_name)
+            end
+
+          alias_selections[name] =
+            if next_field_defn
+              next_nodes = []
+              arguments = @query.arguments_for(alias_node, next_field_defn)
+              arguments = arguments.is_a?(::GraphQL::Execution::Interpreter::Arguments) ? arguments.keyword_arguments : arguments
+              @ast_nodes.each do |ast_node|
+                ast_node.selections.each do |selection|
+                  if GraphQL::FragmentCache.graphql_ruby_after_2_0_13?
+                    find_selected_nodes(selection, next_field_defn, arguments: arguments, matches: next_nodes)
+                  else
+                    find_selected_nodes(selection, next_field_name, next_field_defn, arguments: arguments, matches: next_nodes)
+                  end
+                end
+              end
+
+              if next_nodes.any?
+                ::GraphQL::Execution::Lookahead.new(query: @query, ast_nodes: next_nodes, field: next_field_defn, owner_type: selected_type)
+              else
+                ::GraphQL::Execution::Lookahead::NULL_LOOKAHEAD
+              end
+            else
+              ::GraphQL::Execution::Lookahead::NULL_LOOKAHEAD
+            end
+        end
+
+        def alias_selections
+          return @alias_selections if defined?(@alias_selections)
+          @alias_selections ||= {}
+        end
+
+        def lookup_alias_node(nodes, name)
+          return if nodes.empty?
+
+          nodes.find do |node|
+            if node.is_a?(GraphQL::Language::Nodes::FragmentSpread)
+              node = @query.fragments[node.name]
+              raise("Invariant: Can't look ahead to nonexistent fragment #{node.name} (found: #{@query.fragments.keys})") unless node
+            end
+
+            return node if node.alias?(name)
+            child = lookup_alias_node(node.children, name)
+            return child if child
+          end
+        end
+      end
+    })
+
+    # Builds cache key for fragment
+    class CacheKeyBuilder
+      using RubyNext
+
+      class << self
+        def call(**options)
+          new(**options).build
+        end
+      end
+
+      attr_reader :query, :path, :object, :schema
+
+      def initialize(object: nil, query:, path:, **options)
+        @object = object
+        @query = query
+        @schema = query.schema
+        @path = path
+        @options = options
+      end
+
+      def build
+        [
+          GraphQL::FragmentCache.namespace,
+          implicit_cache_key,
+          object_cache_key
+        ].compact.join("/")
+      end
+
+      private
+
+      def implicit_cache_key
+        Digest::SHA1.hexdigest("#{schema_cache_key}/#{query_cache_key}")
+      end
+
+      def schema_cache_key
+        @options.fetch(:schema_cache_key) { schema.schema_cache_key }
+      end
+
+      def query_cache_key
+        @options.fetch(:query_cache_key) { "#{path_cache_key}[#{selections_cache_key}]" }
+      end
+
+      def selections_cache_key
+        current_root =
+          path.reduce(query.lookahead) { |lkhd, field_name|
+            # Handle cached fields inside collections:
+            next lkhd if field_name.is_a?(Integer)
+
+            lkhd.selection_with_alias(field_name)
+          }
+
+        current_root.selections.to_selections_key
+      end
+
+      def path_cache_key
+        @options.fetch(:path_cache_key) do
+          lookahead = query.lookahead
+
+          path.map { |field_name|
+            # Handle cached fields inside collections:
+            next field_name if field_name.is_a?(Integer)
+
+            lookahead = lookahead.selection_with_alias(field_name)
+            raise "Failed to look ahead the field: #{field_name}" if lookahead.is_a?(::GraphQL::Execution::Lookahead::NullLookahead)
+
+            next lookahead.field.name if lookahead.arguments.empty?
+
+            args = lookahead.arguments.map { |_1, _2| "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")
+            "#{lookahead.field.name}(#{args})"
+          }.join("/")
+        end
+      end
+
+      def traverse_argument(argument)
+        return argument unless argument.is_a?(GraphQL::Schema::InputObject)
+
+        "{#{argument.map { |_1, _2| "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")}}"
+      end
+
+      def object_cache_key
+        @options[:object_cache_key] || object_key(object)
+      end
+
+      def object_key(obj)
+        obj&._graphql_cache_key
+      end
+    end
+  end
+end

data/lib/.rbnext/2.7/graphql/fragment_cache/ext/graphql_cache_key.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module FragmentCache
+    module Ext
+      # Adds #_graphql_cache_key method to Object,
+      # which just call #graphql_cache_key or #cache_key.
+      #
+      # For other core classes returns string representation.
+      #
+      # Raises ArgumentError otherwise.
+      #
+      # We use a refinement to avoid case/if statements for type checking
+      refine Object do
+        def _graphql_cache_key
+          return graphql_cache_key if respond_to?(:graphql_cache_key)
+          return cache_key if respond_to?(:cache_key)
+          return to_a._graphql_cache_key if respond_to?(:to_a)
+
+          to_s
+        end
+      end
+
+      refine Array do
+        def _graphql_cache_key
+          map { |_1| _1._graphql_cache_key }.join("/")
+        end
+      end
+
+      refine NilClass do
+        def _graphql_cache_key
+          ""
+        end
+      end
+
+      refine TrueClass do
+        def _graphql_cache_key
+          "t"
+        end
+      end
+
+      refine FalseClass do
+        def _graphql_cache_key
+          "f"
+        end
+      end
+
+      refine String do
+        def _graphql_cache_key
+          self
+        end
+      end
+
+      refine Symbol do
+        def _graphql_cache_key
+          to_s
+        end
+      end
+
+      if RUBY_PLATFORM.match?(/java/i)
+        refine Integer do
+          def _graphql_cache_key
+            to_s
+          end
+        end
+
+        refine Float do
+          def _graphql_cache_key
+            to_s
+          end
+        end
+      else
+        refine Numeric do
+          def _graphql_cache_key
+            to_s
+          end
+        end
+      end
+
+      refine Time do
+        def _graphql_cache_key
+          to_s
+        end
+      end
+
+      refine Module do
+        def _graphql_cache_key
+          name
+        end
+      end
+    end
+  end
+end

data/lib/graphql/fragment_cache/cache_key_builder.rb

@@ -62,7 +62,12 @@ module GraphQL
           next_field_name = alias_node.name
 
           # From https://github.com/rmosolgo/graphql-ruby/blob/1a9a20f3da629e63ea8e5ee8400be82218f9edc3/lib/graphql/execution/lookahead.rb#L91
-          next_field_defn = get_class_based_field(selected_type, next_field_name)
+          next_field_defn =
+            if GraphQL::FragmentCache.graphql_ruby_before_2_0?
+              get_class_based_field(selected_type, next_field_name)
+            else
+              @query.get_field(selected_type, next_field_name)
+            end
 
           alias_selections[name] =
             if next_field_defn
@@ -71,7 +76,11 @@ module GraphQL
               arguments = arguments.is_a?(::GraphQL::Execution::Interpreter::Arguments) ? arguments.keyword_arguments : arguments
               @ast_nodes.each do |ast_node|
                 ast_node.selections.each do |selection|
-                  find_selected_nodes(selection, next_field_name, next_field_defn, arguments: arguments, matches: next_nodes)
+                  if GraphQL::FragmentCache.graphql_ruby_after_2_0_13?
+                    find_selected_nodes(selection, next_field_defn, arguments: arguments, matches: next_nodes)
+                  else
+                    find_selected_nodes(selection, next_field_name, next_field_defn, arguments: arguments, matches: next_nodes)
+                  end
                 end
               end
 

data/lib/graphql/fragment_cache/field_extension.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/fragment_cache/schema/lazy_cache_resolver"
+
 module GraphQL
   module FragmentCache
     # Wraps resolver with cache method

data/lib/graphql/fragment_cache/fragment.rb

@@ -8,19 +8,41 @@ module GraphQL
 
     # Represents a single fragment to cache
     class Fragment
+      NIL_IN_CACHE = Object.new
+
+      class << self
+        def read_multi(fragments)
+          unless FragmentCache.cache_store.respond_to?(:read_multi)
+            return fragments.map { |f| [f, f.read] }.to_h
+          end
+
+          fragments_to_cache_keys = fragments
+            .map { |f| [f, f.cache_key] }.to_h
+
+          cache_keys = fragments_to_cache_keys.values
+
+          cache_keys_to_values = FragmentCache.cache_store.read_multi(*cache_keys)
+
+          fetched_fragments_to_values = cache_keys_to_values
+            .map { |key, val| [fragments_to_cache_keys.key(key), val] }
+            .to_h
+
+          fetched_fragments_to_values
+        end
+      end
+
       attr_reader :options, :path, :context
 
       def initialize(context, **options)
         @context = context
+        @keep_in_context = options.delete(:keep_in_context)
         @options = options
         @path = interpreter_context[:current_path]
       end
 
-      NIL_IN_CACHE = Object.new
-
-      def read(keep_in_context = false)
+      def read
         return nil if context[:renew_cache] == true
-        return read_from_context { value_from_cache } if keep_in_context
+        return read_from_context { value_from_cache } if @keep_in_context
 
         value_from_cache
       end

data/lib/graphql/fragment_cache/object_helpers.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "graphql/fragment_cache/fragment"
+require "graphql/fragment_cache/schema/lazy_cache_resolver"
 
 module GraphQL
   module FragmentCache
@@ -44,14 +45,7 @@ module GraphQL
 
         fragment = Fragment.new(context_to_use, **options)
 
-        keep_in_context = options.delete(:keep_in_context)
-        if (cached = fragment.read(keep_in_context))
-          return cached == Fragment::NIL_IN_CACHE ? nil : raw_value(cached)
-        end
-
-        (block_given? ? block.call : object_to_cache).tap do |resolved_value|
-          context_to_use.fragments << fragment
-        end
+        GraphQL::FragmentCache::Schema::LazyCacheResolver.new(fragment, context_to_use, object_to_cache, &block)
       end
     end
   end

data/lib/graphql/fragment_cache/schema/lazy_cache_resolver.rb

@@ -0,0 +1,41 @@
+require "graphql/fragment_cache/fragment"
+
+module GraphQL
+  module FragmentCache
+    module Schema
+      using Ext
+      class LazyCacheResolver
+        def initialize(fragment, query_ctx, object_to_cache, &block)
+          @fragment = fragment
+          @query_ctx = query_ctx
+          @object_to_cache = object_to_cache
+          @lazy_state = query_ctx[:lazy_cache_resolver_statez] ||= {
+            pending_fragments: Set.new,
+            resolved_fragments: {}
+          }
+          @block = block
+
+          @lazy_state[:pending_fragments] << @fragment
+        end
+
+        def resolve
+          unless @lazy_state[:resolved_fragments].key?(@fragment)
+            resolved_fragments = Fragment.read_multi(@lazy_state[:pending_fragments].to_a)
+            @lazy_state[:pending_fragments].clear
+            resolved_fragments.each { |key, value| @lazy_state[:resolved_fragments][key] = value }
+          end
+
+          cached = @lazy_state[:resolved_fragments][@fragment]
+
+          if cached
+            return cached == Fragment::NIL_IN_CACHE ? nil : GraphQL::Execution::Interpreter::RawValue.new(cached)
+          end
+
+          (@block ? @block.call : @object_to_cache).tap do |resolved_value|
+            @query_ctx.fragments << @fragment
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/fragment_cache/schema/tracer.rb

@@ -23,7 +23,7 @@ module GraphQL
           end
 
           def verify_connections!(context)
-            return if GraphQL::FragmentCache.graphql_ruby_1_12_or_later? || context.schema.new_connections?
+            return if context.schema.new_connections?
 
             raise StandardError,
               "GraphQL::Pagination::Connections should be enabled for connection caching"

data/lib/graphql/fragment_cache/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module FragmentCache
-    VERSION = "1.10.0"
+    VERSION = "1.13.0"
   end
 end

data/lib/graphql/fragment_cache.rb

@@ -11,6 +11,7 @@ require "graphql/fragment_cache/connections/patch"
 require "graphql/fragment_cache/schema/patch"
 require "graphql/fragment_cache/schema/tracer"
 require "graphql/fragment_cache/schema/instrumentation"
+require "graphql/fragment_cache/schema/lazy_cache_resolver"
 
 require "graphql/fragment_cache/memory_store"
 
@@ -30,6 +31,7 @@ module GraphQL
         schema_defn.tracer(Schema::Tracer)
         schema_defn.instrument(:query, Schema::Instrumentation)
         schema_defn.extend(Schema::Patch)
+        schema_defn.lazy_resolve(Schema::LazyCacheResolver, :resolve)
 
         GraphQL::Pagination::Connections.prepend(Connections::Patch)
       end
@@ -50,29 +52,28 @@ module GraphQL
         @cache_store = store
       end
 
-      def graphql_ruby_1_12_or_later?
-        Gem::Dependency.new("graphql", ">= 1.12.0").match?("graphql", GraphQL::VERSION)
+      def graphql_ruby_before_2_0?
+        check_graphql_version "< 2.0.0"
+      end
+
+      def graphql_ruby_after_2_0_13?
+        check_graphql_version "> 2.0.13"
       end
 
       private
 
-      def verify_interpreter_and_analysis!(schema_defn)
-        if graphql_ruby_1_12_or_later?
-          unless schema_defn.interpreter?
-            raise StandardError,
-              "GraphQL::Execution::Execute should not be enabled for fragment caching"
-          end
+      def check_graphql_version(predicate)
+        Gem::Dependency.new("graphql", predicate).match?("graphql", GraphQL::VERSION)
+      end
 
-          unless schema_defn.analysis_engine == GraphQL::Analysis::AST
-            raise StandardError,
-              "GraphQL::Analysis should not be enabled for fragment caching"
-          end
-        else
+      def verify_interpreter_and_analysis!(schema_defn)
+        if graphql_ruby_before_2_0?
           unless schema_defn.interpreter?
             raise StandardError,
               "GraphQL::Execution::Interpreter should be enabled for fragment caching"
           end
 
+          puts "schema_defn.analysis_engine #{schema_defn.analysis_engine}"
           unless schema_defn.analysis_engine == GraphQL::Analysis::AST
             raise StandardError,
               "GraphQL::Analysis::AST should be enabled for fragment caching"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-fragment_cache
 version: !ruby/object:Gem::Version
-  version: 1.10.0
+  version: 1.13.0
 platform: ruby
 authors:
 - DmitryTsepelev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-01-30 00:00:00.000000000 Z
+date: 2022-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.10.8
+        version: 1.12.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.10.8
+        version: 1.12.0
 - !ruby/object:Gem::Dependency
   name: ruby-next
   requirement: !ruby/object:Gem::Requirement
@@ -190,6 +190,10 @@ files:
 - README.md
 - bin/console
 - bin/setup
+- lib/.rbnext/2.3/graphql/fragment_cache/cache_key_builder.rb
+- lib/.rbnext/2.3/graphql/fragment_cache/memory_store.rb
+- lib/.rbnext/2.7/graphql/fragment_cache/cache_key_builder.rb
+- lib/.rbnext/2.7/graphql/fragment_cache/ext/graphql_cache_key.rb
 - lib/graphql-fragment_cache.rb
 - lib/graphql/fragment_cache.rb
 - lib/graphql/fragment_cache/cache_key_builder.rb
@@ -205,6 +209,7 @@ files:
 - lib/graphql/fragment_cache/rails/cache_key_builder.rb
 - lib/graphql/fragment_cache/railtie.rb
 - lib/graphql/fragment_cache/schema/instrumentation.rb
+- lib/graphql/fragment_cache/schema/lazy_cache_resolver.rb
 - lib/graphql/fragment_cache/schema/patch.rb
 - lib/graphql/fragment_cache/schema/tracer.rb
 - lib/graphql/fragment_cache/version.rb
@@ -230,7 +235,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: Fragment cache for graphql-ruby