graphql-fragment_cache 1.6.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5c6796b976bd78fc44c483dd9b39684081ee07bfb8b791d3a9bf00a31893ae7
-  data.tar.gz: fc772a7e8c4319bd5b5bff5978ad20293334ac872be2fed170bc9084326874a0
+  metadata.gz: f193c09fd4f7682db9677d754964852e63b7541f2f2fa6d52ea81c8ee8b894fd
+  data.tar.gz: 328017637ba3c31c9c9af6c6beacdb63e696b13d6065c12d73b02874fb2e29d5
 SHA512:
-  metadata.gz: 597046420b6342ca1c7e1429c1e44d36fa3a0eca9592d194318213614f3dc95c10eadf5ea616a13e8582f354caed9bf425b639149b15a7d9c3647e970fd3a780
-  data.tar.gz: 1aa900bb9840ccb836498b79ef0031859304a328bebbce86fc32399e468d43ae1279daedc1bb6444e4366450ab5b11974dec679d4e11d8688fbea9f6bdf1c4a0
+  metadata.gz: 9fd90630bd8a8505e2fe1a1277b621d22e2c62a23270a87a5487b56fdde57b980859611f80bfeb956915b581e396ee89a75da11548edebddf321ba45a0640e6c
+  data.tar.gz: 43fa3b1709999e950b8002f7764e0e63bdacd9aa32db644ead959e6cc12c0df8d92c26423300af4aad59139a8a30290a2c82cfe0cc4ff412656c20d4c64919e4

data/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## 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][])
@@ -99,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.
@@ -155,7 +163,7 @@ class QueryType < BaseObject
 end
 ```
 
-### User-provided cache key
+### 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):
 
@@ -184,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
@@ -260,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:
@@ -350,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

@@ -126,19 +126,19 @@ module GraphQL
       end
 
       def build
-        Digest::SHA1.hexdigest("#{schema_cache_key}/#{query_cache_key}").then do |base_key|
-          if @options[:object_cache_key]
-            "#{base_key}/#{@options[:object_cache_key]}"
-          elsif object
-            "#{base_key}/#{object_key(object)}"
-          else
-            base_key
-          end
-        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
@@ -184,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,7 @@ module GraphQL
   module FragmentCache
     class << self
       attr_reader :cache_store
+      attr_accessor :namespace
 
       def use(schema_defn, options = {})
         verify_interpreter_and_analysis!(schema_defn)
@@ -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"

data/lib/graphql/fragment_cache/cache_key_builder.rb

@@ -126,19 +126,19 @@ module GraphQL
       end
 
       def build
-        Digest::SHA1.hexdigest("#{schema_cache_key}/#{query_cache_key}").then do |base_key|
-          if @options[:object_cache_key]
-            "#{base_key}/#{@options[:object_cache_key]}"
-          elsif object
-            "#{base_key}/#{object_key(object)}"
-          else
-            base_key
-          end
-        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
@@ -184,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/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

data/lib/graphql/fragment_cache/object_helpers.rb

@@ -25,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/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module FragmentCache
-    VERSION = "1.6.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.6.0
+  version: 1.7.0
 platform: ruby
 authors:
 - DmitryTsepelev
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-03-13 00:00:00.000000000 Z
+date: 2021-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -176,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