graphql-fragment_cache 1.4.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dab2cb1f4c27251da27c938bd8a0392f3ad0edcb5c54ba1d7d83d9e2f9c4b12b
-  data.tar.gz: 8e5323ed6bf476d185c993b8165e292d4d7e70df56fa1ae1ad32da2ae7bc0880
+  metadata.gz: f193c09fd4f7682db9677d754964852e63b7541f2f2fa6d52ea81c8ee8b894fd
+  data.tar.gz: 328017637ba3c31c9c9af6c6beacdb63e696b13d6065c12d73b02874fb2e29d5
 SHA512:
-  metadata.gz: 90eebb6973db225980926d330d93ca70a50768279bb727cf702f1bd905628cf7969e1af5025a6fefb1f9785d1fc008fd560d236fbe6315821a6dd2f92243ef56
-  data.tar.gz: b26090f37a4b20ce45a256880b708c17a77871d8e8f5d95c1b34f171062306332f1bf9a549ab92bce5a326a2327d5b8a4f8106e2b2b4ac338bbd257cec8e6a21
+  metadata.gz: 9fd90630bd8a8505e2fe1a1277b621d22e2c62a23270a87a5487b56fdde57b980859611f80bfeb956915b581e396ee89a75da11548edebddf321ba45a0640e6c
+  data.tar.gz: 43fa3b1709999e950b8002f7764e0e63bdacd9aa32db644ead959e6cc12c0df8d92c26423300af4aad59139a8a30290a2c82cfe0cc4ff412656c20d4c64919e4

data/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 ## master
 
+## 1.7.0 (2021-04-30)
+
+- [PR#62](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/62) Add a way to force a cache miss ([@jeromedalbert][])
+- [PR#61](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/61) Add conditional caching ([@jeromedalbert][])
+- [PR#64](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/64) Add a cache namespace ([@jeromedalbert][])
+- [PR#63](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/63) Add a configure block notation ([@jeromedalbert][])
+
+## 1.6.0 (2021-03-13)
+
+- [PR#54](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/54) Include arguments in selections_cache_key ([@bbugh][])
+
+## 1.5.1 (2021-03-10)
+
+- [PR#53](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/53) Use thread-safe query result for final_value ([@bbugh][])
+- [PR#51](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/51) Do not cache fragments without final value ([@DmitryTsepelev][])
+
+## 1.5.0 (2021-02-20)
+
+- [PR#50](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/50) Add object_cache_key to CacheKeyBuilder ([@bbugh][])
+
+## 1.4.1 (2021-01-21)
+
+- [PR#48](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/48) Support graphql-ruby 1.12 ([@DmitryTsepelev][])
+
 ## 1.4.0 (2020-12-03)
 
 - [PR#41](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/41) Add `keep_in_context` option ([@DmitryTsepelev][])
@@ -82,3 +106,4 @@
 [@ssnickolay]: https://github.com/ssnickolay
 [@reabiliti]: https://github.com/reabiliti
 [@bbugh]: https://github.com/bbugh
+[@jeromedalbert]: https://github.com/jeromedalbert

data/README.md

@@ -80,11 +80,19 @@ end
 
 ## Cache key generation
 
-Cache keys consist of implicit and explicit (provided by user) parts.
+Cache keys consist of the following parts: namespace, implicit key, and explicit key.
+
+### Cache namespace
+
+You can optionally define a namespace that will be prefixed to every cache key:
+
+```ruby
+GraphQL::FragmentCache.namespace = "my-prefix"
+```
 
 ### Implicit cache key
 
-Implicit part of a cache key (its prefix) contains the information about the schema and the current query. It includes:
+Implicit part of a cache key contains the information about the schema and the current query. It includes:
 
 - Hex gsdigest of the schema definition (to make sure cache is cleared when the schema changes).
 - The current query fingerprint consisting of a _path_ to the field, arguments information and the selections set.
@@ -112,10 +120,10 @@ selections_cache_key = "[#{%w[id name].join(".")}]"
 
 query_cache_key = Digest::SHA1.hexdigest("#{path_cache_key}#{selections_cache_key}")
 
-cache_key = "#{schema_cache_key}/#{query_cache_key}"
+cache_key = "#{schema_cache_key}/#{query_cache_key}/#{object_cache_key}"
 ```
 
-You can override `schema_cache_key`, `query_cache_key` or `path_cache_key` by passing parameters to the `cache_fragment` calls:
+You can override `schema_cache_key`, `query_cache_key`, `path_cache_key` or `object_cache_key` by passing parameters to the `cache_fragment` calls:
 
 ```ruby
 class QueryType < BaseObject
@@ -140,7 +148,22 @@ class PostType < BaseObject
 end
 ```
 
-### User-provided cache key
+Overriding `object_cache_key` is helpful in the case where the value that is cached is different than the one used as a key, like a database query that is pre-processed before caching.
+
+```ruby
+class QueryType < BaseObject
+  field :post, PostType, null: true do
+    argument :id, ID, required: true
+  end
+
+  def post(id:)
+    query = Post.where("updated_at < ?", Time.now - 1.day)
+    cache_fragment(object_cache_key: query.cache_key) { query.some_process }
+  end
+end
+```
+
+### User-provided cache key (custom key)
 
 In most cases you want your cache key to depend on the resolved object (say, `ActiveRecord` model). You can do that by passing an argument to the `#cache_fragment` method in a similar way to Rails views [`#cache` method](https://guides.rubyonrails.org/caching_with_rails.html#fragment-caching):
 
@@ -169,6 +192,36 @@ cache_fragment(post)
 cache_fragment(post) { post }
 ```
 
+Using literals: Even when using a same string for all queries, the cache changes per argument and per selection set (because of the query_key).
+
+```ruby
+def post(id:)
+  cache_fragment("find_post") { Post.find(id) }
+end
+```
+
+Combining with options:
+
+```ruby
+def post(id:)
+  cache_fragment("find_post", expires_in: 5.minutes) { Post.find(id) }
+end
+```
+
+Dynamic cache key:
+
+```ruby
+def post(id:)
+  last_updated_at = Post.select(:updated_at).find_by(id: id)&.updated_at
+  cache_fragment(last_updated_at, expires_in: 5.minutes) { Post.find(id) }
+end
+```
+
+Note the usage of `.select(:updated_at)` at the cache key field to make this verifying query as fastest and light as possible.
+
+You can also add touch options for the belongs_to association e.g author's `belongs_to: :post` to have a `touch: true`.
+So that it invalidates the Post when the author is updated.
+
 When using `cache_fragment:` option, it's only possible to use the resolved value as a cache key by setting:
 
 ```ruby
@@ -198,6 +251,7 @@ end
 
 The way cache key part is generated for the passed argument is the following:
 
+- Use `object_cache_key: "some_cache_key"` if passed to `cache_fragment`
 - Use `#graphql_cache_key` if implemented.
 - Use `#cache_key` (or `#cache_key_with_version` for modern Rails) if implemented.
 - Use `self.to_s` for _primitive_ types (strings, symbols, numbers, booleans).
@@ -244,12 +298,42 @@ class QueryType < BaseObject
 end
 ```
 
+## Conditional caching
+
+Use the `if:` (or `unless:`) option:
+
+```ruby
+def post(id:)
+  cache_fragment(if: current_user.nil?) { Post.find(id) }
+end
+
+# or
+
+field :post, PostType, cache_fragment: {if: -> { current_user.nil? }} do
+  argument :id, ID, required: true
+end
+```
+
+## Renewing the cache
+
+You can force the cache to renew during query execution by adding
+`renew_cache: true` to the query context:
+
+```ruby
+MyAppSchema.execute("query { posts { title } }", context: {renew_cache: true})
+```
+
+This will treat any cached value as missing even if it's present, and store
+fresh new computed values in the cache. This can be useful for cache warmers.
+
 ## Cache storage and options
 
 It's up to your to decide which caching engine to use, all you need is to configure the cache store:
 
 ```ruby
-GraphQL::FragmentCache.cache_store = MyCacheStore.new
+GraphQL::FragmentCache.configure do |config|
+  config.cache_store = MyCacheStore.new
+end
 ```
 
 Or, in Rails:
@@ -334,7 +418,30 @@ This can reduce a number of cache calls but _increase_ memory usage, because the
 
 ## Limitations
 
-Caching does not work for Union types, because of the `Lookahead` implementation: it requires the exact type to be passed to the `selection` method (you can find the [discussion](https://github.com/rmosolgo/graphql-ruby/pull/3007) here). This method is used for cache key building, and I haven't found a workaround yet ([PR in progress](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/30)). If you get `Failed to look ahead the field` error — please pass `query_cache_key` explicitly:
+1. `Schema#execute`, [graphql-batch](https://github.com/Shopify/graphql-batch) and _graphql-ruby-fragment_cache_ do not [play well](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/issues/45) together. The problem appears when `cache_fragment` is _inside_ the `.then` block:
+
+```ruby
+def cached_author_inside_batch
+  AuthorLoader.load(object).then do |author|
+    cache_fragment(author, context: context)
+  end
+end
+```
+
+The problem is that context is not [properly populated](https://github.com/rmosolgo/graphql-ruby/issues/3397) inside the block (the gem uses `:current_path` to build the cache key). There are two possible workarounds: use [dataloaders](https://graphql-ruby.org/dataloader/overview.html) or manage `:current_path` manually:
+
+```ruby
+def cached_author_inside_batch
+  outer_path = context.namespace(:interpreter)[:current_path]
+
+  AuthorLoader.load(object).then do |author|
+    context.namespace(:interpreter)[:current_path] = outer_path
+    cache_fragment(author, context: context)
+  end
+end
+```
+
+2. Caching does not work for Union types, because of the `Lookahead` implementation: it requires the exact type to be passed to the `selection` method (you can find the [discussion](https://github.com/rmosolgo/graphql-ruby/pull/3007) here). This method is used for cache key building, and I haven't found a workaround yet ([PR in progress](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/30)). If you get `Failed to look ahead the field` error — please pass `query_cache_key` explicitly:
 
 ```ruby
 field :cached_avatar_url, String, null: false

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

@@ -0,0 +1,196 @@
+# 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
+
+            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 = get_class_based_field(selected_type, next_field_name)
+
+          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|
+                  find_selected_nodes(selection, next_field_name, next_field_defn, arguments: arguments, matches: next_nodes)
+                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.7/graphql/fragment_cache/cache_key_builder.rb

@@ -11,10 +11,24 @@ module GraphQL
 
     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}]"
-            "#{val.field.name}#{children}"
+
+            field_name = val.field.name
+
+            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
@@ -112,14 +126,19 @@ module GraphQL
       end
 
       def build
-        Digest::SHA1.hexdigest("#{schema_cache_key}/#{query_cache_key}").then do |base_key|
-          next base_key unless object
-          "#{base_key}/#{object_key(object)}"
-        end
+        [
+          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
@@ -165,8 +184,12 @@ module GraphQL
         "{#{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
+        obj&._graphql_cache_key
       end
     end
   end

data/lib/graphql/fragment_cache.rb

@@ -21,9 +21,10 @@ module GraphQL
   module FragmentCache
     class << self
       attr_reader :cache_store
+      attr_accessor :namespace
 
       def use(schema_defn, options = {})
-        verify_interpreter!(schema_defn)
+        verify_interpreter_and_analysis!(schema_defn)
 
         schema_defn.tracer(Schema::Tracer)
         schema_defn.instrument(:query, Schema::Instrumentation)
@@ -32,6 +33,10 @@ module GraphQL
         GraphQL::Pagination::Connections.prepend(Connections::Patch)
       end
 
+      def configure
+        yield self
+      end
+
       def cache_store=(store)
         unless store.respond_to?(:read)
           raise ArgumentError, "Store must implement #read(key) method"
@@ -44,17 +49,33 @@ module GraphQL
         @cache_store = store
       end
 
-      private
+      def graphql_ruby_1_12_or_later?
+        Gem::Dependency.new("graphql", ">= 1.12.0").match?("graphql", GraphQL::VERSION)
+      end
 
-      def verify_interpreter!(schema_defn)
-        unless schema_defn.interpreter?
-          raise StandardError,
-            "GraphQL::Execution::Interpreter should be enabled for fragment caching"
-        end
+      private
 
-        unless schema_defn.analysis_engine == GraphQL::Analysis::AST
-          raise StandardError,
-            "GraphQL::Analysis::AST should be enabled for fragment caching"
+      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
+
+          unless schema_defn.analysis_engine == GraphQL::Analysis::AST
+            raise StandardError,
+              "GraphQL::Analysis should not be enabled for fragment caching"
+          end
+        else
+          unless schema_defn.interpreter?
+            raise StandardError,
+              "GraphQL::Execution::Interpreter should be enabled for fragment caching"
+          end
+
+          unless schema_defn.analysis_engine == GraphQL::Analysis::AST
+            raise StandardError,
+              "GraphQL::Analysis::AST should be enabled for fragment caching"
+          end
         end
       end
     end

data/lib/graphql/fragment_cache/cache_key_builder.rb

@@ -11,10 +11,24 @@ module GraphQL
 
     using(Module.new {
       refine Array do
+        def traverse_argument(argument)
+          return argument unless argument.is_a?(GraphQL::Schema::InputObject)
+
+          "{#{argument.map { "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")}}"
+        end
+
         def to_selections_key
           map { |val|
             children = val.selections.empty? ? "" : "[#{val.selections.to_selections_key}]"
-            "#{val.field.name}#{children}"
+
+            field_name = val.field.name
+
+            unless val.arguments.empty?
+              args = val.arguments.map { "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")
+              field_name += "(#{args})"
+            end
+
+            "#{field_name}#{children}"
           }.join(".")
         end
       end
@@ -112,14 +126,19 @@ module GraphQL
       end
 
       def build
-        Digest::SHA1.hexdigest("#{schema_cache_key}/#{query_cache_key}").then do |base_key|
-          next base_key unless object
-          "#{base_key}/#{object_key(object)}"
-        end
+        [
+          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
@@ -165,8 +184,12 @@ module GraphQL
         "{#{argument.map { "#{_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
+        obj&._graphql_cache_key
       end
     end
   end

data/lib/graphql/fragment_cache/cacher.rb

@@ -20,17 +20,21 @@ module GraphQL
         private
 
         def batched_persist(query)
-          query.context.fragments.group_by(&:options).each do |options, group|
+          select_valid_fragments(query).group_by(&:options).each do |options, group|
             hash = group.map { |fragment| [fragment.cache_key, fragment.value] }.to_h
             FragmentCache.cache_store.write_multi(hash, **options)
           end
         end
 
         def persist(query)
-          query.context.fragments.each do |fragment|
+          select_valid_fragments(query).each do |fragment|
             FragmentCache.cache_store.write(fragment.cache_key, fragment.value, **fragment.options)
           end
         end
+
+        def select_valid_fragments(query)
+          query.context.fragments.select(&:with_final_value?)
+        end
       end
     end
   end

data/lib/graphql/fragment_cache/field_extension.rb

@@ -39,6 +39,13 @@ module GraphQL
       def resolve(object:, arguments:, **_options)
         resolved_value = NOT_RESOLVED
 
+        if @cache_options[:if].is_a?(Proc)
+          @cache_options[:if] = object.instance_exec(&@cache_options[:if])
+        end
+        if @cache_options[:unless].is_a?(Proc)
+          @cache_options[:unless] = object.instance_exec(&@cache_options[:unless])
+        end
+
         object_for_key = if @context_key
           Array(@context_key).map { |key| object.context[key] }
         elsif @cache_key == :object
@@ -46,7 +53,6 @@ module GraphQL
         elsif @cache_key == :value
           resolved_value = yield(object, arguments)
         end
-
         cache_fragment_options = @cache_options.merge(object: object_for_key)
 
         object.cache_fragment(**cache_fragment_options) do

data/lib/graphql/fragment_cache/fragment.rb

@@ -19,6 +19,7 @@ module GraphQL
       NIL_IN_CACHE = Object.new
 
       def read(keep_in_context = false)
+        return nil if context[:renew_cache] == true
         return read_from_context { value_from_cache } if keep_in_context
 
         value_from_cache
@@ -28,6 +29,10 @@ module GraphQL
         @cache_key ||= CacheKeyBuilder.call(path: path, query: context.query, **options)
       end
 
+      def with_final_value?
+        !final_value.nil?
+      end
+
       def value
         final_value.dig(*path)
       end
@@ -53,7 +58,7 @@ module GraphQL
       end
 
       def final_value
-        @final_value ||= interpreter_context[:runtime].final_value
+        @final_value ||= context.query.result["data"]
       end
     end
   end

data/lib/graphql/fragment_cache/object_helpers.rb

@@ -11,9 +11,13 @@ module GraphQL
       extend Forwardable
 
       def self.included(base)
-        return if base < GraphQL::Execution::Interpreter::HandlesRawValue
+        return if base.method_defined?(:raw_value)
 
-        base.include(GraphQL::Execution::Interpreter::HandlesRawValue)
+        base.include(Module.new {
+          def raw_value(obj)
+            GraphQL::Execution::Interpreter::RawValue.new(obj)
+          end
+        })
       end
 
       NO_OBJECT = Object.new
@@ -21,6 +25,13 @@ module GraphQL
       def cache_fragment(object_to_cache = NO_OBJECT, **options, &block)
         raise ArgumentError, "Block or argument must be provided" unless block_given? || object_to_cache != NO_OBJECT
 
+        if options.key?(:if) || options.key?(:unless)
+          disabled = options.key?(:if) ? !options.delete(:if) : options.delete(:unless)
+          if disabled
+            return block_given? ? block.call : object_to_cache
+          end
+        end
+
         options[:object] = object_to_cache if object_to_cache != NO_OBJECT
 
         context_to_use = options.delete(:context)

data/lib/graphql/fragment_cache/rails/cache_key_builder.rb

@@ -5,6 +5,7 @@ module GraphQL
     # Extends key builder to use .expand_cache_key in Rails
     class CacheKeyBuilder
       def object_key(obj)
+        return nil if obj.nil?
         return obj.graphql_cache_key if obj.respond_to?(:graphql_cache_key)
         return obj.cache_key_with_version if obj.respond_to?(:cache_key_with_version)
         return obj.cache_key if obj.respond_to?(:cache_key)

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

@@ -23,7 +23,7 @@ module GraphQL
           end
 
           def verify_connections!(context)
-            return if context.schema.new_connections?
+            return if GraphQL::FragmentCache.graphql_ruby_1_12_or_later? || 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.4.0"
+    VERSION = "1.7.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-fragment_cache
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.7.0
 platform: ruby
 authors:
 - DmitryTsepelev
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-12-03 00:00:00.000000000 Z
+date: 2021-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -150,6 +150,20 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 0.4.9
+- !ruby/object:Gem::Dependency
+  name: graphql-batch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Fragment cache for graphql-ruby
 email:
 - dmitry.a.tsepelev@gmail.com
@@ -162,6 +176,7 @@ 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