graphql-fragment_cache 1.4.1 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 89da5923396f256876f648b15e23b77b14a731b4e5b642fc67074d50fcefc5c3
-  data.tar.gz: b4c5a2fe21477726e41835168a8768e8adba9d03d3bf3f618705a31e0ee391a1
+  metadata.gz: 7ad8755b7ad0579ac5b5a663a9c680fd5132ef818f39881b4df5d2a9c09a3d4b
+  data.tar.gz: b2132f313316e1f413b2fd07120b3c2a8c0465f66cc6183f32661a8f606074a4
 SHA512:
-  metadata.gz: 470dc39abc207c3d3db874d1a954d665fadf105c31b3e62ef18bfe0d60ca002e505e7861a52ee2ba652a4789f2c3566c2b7e2134fe22d09ef62b6fe17cf95a7d
-  data.tar.gz: ceb3ec4abdf657527aac1e2ca5ab441bb3551a33aefe2fd38c2e1f6cb31e9bbea52b19c9aa30edf10a9e0071593697d4c6cd7f3b9254ad3682a995796375abc4
+  metadata.gz: 562098e2cfdb77fd07eef41b316fff4b052dcd7fab1b1b05672b5c2c5bf7f3627a7f3f754adae2e6a8c902816f7fb78428c85ab6d9e29395b33bfc1bfab4663e
+  data.tar.gz: 309be07ee6de769b32b2d13b258d3e0bd90ee043d4198d10f44c28edcfdbfafc3a52b0f81629fe0b40cc4efb8f8c62b5d801e3c42bec985b8426d205c41e724f

data/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 ## master
 
+## 1.8.0 (2021-05-13)
+
+- [PR#65](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/65) Add default options ([@jeromedalbert][])
+
+## 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][])
@@ -86,3 +110,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,56 @@ 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
+```
+
+## Default options
+
+You can configure default options that will be passed to all `cache_fragment`
+calls and `cache_fragment:` configurations. For example:
+
+```ruby
+GraphQL::FragmentCache.configure do |config|
+  config.default_options = {
+    expires_in: 1.hour, # Expire cache keys after 1 hour
+    schema_cache_key: nil # Do not clear the cache on each schema change
+  }
+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 +432,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,6 +21,8 @@ module GraphQL
   module FragmentCache
     class << self
       attr_reader :cache_store
+      attr_accessor :namespace
+      attr_accessor :default_options
 
       def use(schema_defn, options = {})
         verify_interpreter_and_analysis!(schema_defn)
@@ -32,6 +34,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"
@@ -76,6 +82,7 @@ module GraphQL
     end
 
     self.cache_store = MemoryStore.new
+    self.default_options = {}
   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

@@ -28,7 +28,8 @@ module GraphQL
       end
 
       def initialize(options:, **_rest)
-        @cache_options = options || {}
+        @cache_options = GraphQL::FragmentCache.default_options.merge(options || {})
+        @cache_options[:default_options_merged] = true
 
         @context_key = @cache_options.delete(:context_key)
         @cache_key = @cache_options.delete(:cache_key)
@@ -39,6 +40,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 +54,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

@@ -25,6 +25,17 @@ 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
 
+        unless options.delete(:default_options_merged)
+          options = GraphQL::FragmentCache.default_options.merge(options)
+        end
+
+        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/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module FragmentCache
-    VERSION = "1.4.1"
+    VERSION = "1.8.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-fragment_cache
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 1.8.0
 platform: ruby
 authors:
 - DmitryTsepelev
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-01-21 00:00:00.000000000 Z
+date: 2021-05-13 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