graphql-fragment_cache 1.1.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b8dcfa21629a163b02f1097275602c294eb6e6cad5be237a11f5567c3fedce8c
-  data.tar.gz: 812fde3ac50fcb43ebb5e00c8291817c876a9bb0c7ccaa5544319dd01fb7a143
+  metadata.gz: fc02c6847d8e55983814bba96e0bd303893a1639648530048f0ccf6ab1527eab
+  data.tar.gz: 52530f6e108ed656077a02a78a44dd2cf498e4004b9d27897572f6f77aaec353
 SHA512:
-  metadata.gz: da34c5a7e12669352a0a095338bd52895414a49628d758cf0df6d698fc342f6b94032fdce6bf8df70b866ea6ddf2a5d6666ab7dd7b70050ab0b058448b8dcfca
-  data.tar.gz: 937fa344650d90187acc5985c86b4f3320ed276a03aaf02531484596e1a0b20b09cc2fdb2d4596c8150d3992fdef9c48085623ff1030e16135da7f019b255e46
+  metadata.gz: e5b95e2b3f68011a8cdc0fc23b3a5f117f0ce9c711efcfb504230f6a84fb8c6c53a156d6671f97c8ea52cad199de597954badb2e456d33303b80e6e2e2105bec
+  data.tar.gz: d7275ef053d1127a17476244bd7253cb98dab81df865195b7bae7241bcd6106564af13848dfeaf39676acb96e962be73fb7782274ae4ccce2190065234b5fbf9

data/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 ## master
 
+## 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][])
+
+## 1.3.0 (2020-11-25)
+
+- [PR#39](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/39) Implement `path_cache_key` option ([@DmitryTsepelev][])
+
+## 1.2.0 (2020-10-26)
+
+- [PR#37](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/37) Try to use `cache_key_with_version` or `cache_key` with Rails CacheKeyBuilder ([@bbugh][])
+
 ## 1.1.0 (2020-10-26)
 
 - [PR#38](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/38) Support caching from other places than field or resolver  ([@DmitryTsepelev][])
@@ -69,3 +89,4 @@
 [@palkan]: https://github.com/palkan
 [@ssnickolay]: https://github.com/ssnickolay
 [@reabiliti]: https://github.com/reabiliti
+[@bbugh]: https://github.com/bbugh

data/README.md

@@ -112,10 +112,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` or `query_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
@@ -129,6 +129,8 @@ class QueryType < BaseObject
 end
 ```
 
+Overriding `path_cache_key` might be helpful when you resolve the same object nested in multiple places (e.g., `Post` and `Comment` both have `author`), but want to make sure cache will be invalidated when selection set is different.
+
 Same for the option:
 
 ```ruby
@@ -138,6 +140,21 @@ class PostType < BaseObject
 end
 ```
 
+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
 
 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):
@@ -196,6 +213,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).
@@ -312,6 +330,24 @@ end
 
 With this approach you can use `#cache_fragment` in any place you have an access to the `context`. When context is not available, the error `cannot find context, please pass it explicitly` will be thrown.
 
+## In–memory fragments
+
+If you have a fragment that accessed from multiple times (e.g., if you have a list of items that belong to the same owner, and owner is cached), you can avoid multiple cache reads by using `:keep_in_context` option:
+
+```ruby
+class QueryType < BaseObject
+  field :post, PostType, null: true do
+    argument :id, ID, required: true
+  end
+
+  def post(id:)
+    cache_fragment(keep_in_context: true, expires_in: 5.minutes) { Post.find(id) }
+  end
+end
+```
+
+This can reduce a number of cache calls but _increase_ memory usage, because the value returned from cache will be kept in the GraphQL context until the query is fully resolved.
+
 ## 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:

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

@@ -113,8 +113,13 @@ module GraphQL
 
       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)}"
+          if @options[:object_cache_key]
+            "#{base_key}/#{@options[:object_cache_key]}"
+          elsif object
+            "#{base_key}/#{object_key(object)}"
+          else
+            base_key
+          end
         end
       end
 
@@ -141,20 +146,22 @@ module GraphQL
       end
 
       def path_cache_key
-        lookahead = query.lookahead
+        @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)
+          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)
+            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?
+            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("/")
+            args = lookahead.arguments.map { |_1, _2| "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")
+            "#{lookahead.field.name}(#{args})"
+          }.join("/")
+        end
       end
 
       def traverse_argument(argument)

data/lib/graphql/fragment_cache.rb

@@ -23,7 +23,7 @@ module GraphQL
       attr_reader :cache_store
 
       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)
@@ -44,17 +44,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

@@ -113,8 +113,13 @@ module GraphQL
 
       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)}"
+          if @options[:object_cache_key]
+            "#{base_key}/#{@options[:object_cache_key]}"
+          elsif object
+            "#{base_key}/#{object_key(object)}"
+          else
+            base_key
+          end
         end
       end
 
@@ -141,20 +146,22 @@ module GraphQL
       end
 
       def path_cache_key
-        lookahead = query.lookahead
+        @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)
+          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)
+            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?
+            next lookahead.field.name if lookahead.arguments.empty?
 
-          args = lookahead.arguments.map { "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")
-          "#{lookahead.field.name}(#{args})"
-        }.join("/")
+            args = lookahead.arguments.map { "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")
+            "#{lookahead.field.name}(#{args})"
+          }.join("/")
+        end
       end
 
       def traverse_argument(argument)

data/lib/graphql/fragment_cache/ext/context_fragments.rb

@@ -13,6 +13,10 @@ module GraphQL
         def fragments
           namespace(:fragment_cache)[:fragments] ||= []
         end
+
+        def loaded_fragments
+          namespace(:fragment_cache)[:loaded] ||= {}
+        end
       end
     end
   end

data/lib/graphql/fragment_cache/field_extension.rb

@@ -49,7 +49,7 @@ module GraphQL
 
         cache_fragment_options = @cache_options.merge(object: object_for_key)
 
-        object.cache_fragment(cache_fragment_options) do
+        object.cache_fragment(**cache_fragment_options) do
           resolved_value == NOT_RESOLVED ? yield(object, arguments) : resolved_value
         end
       end

data/lib/graphql/fragment_cache/fragment.rb

@@ -4,6 +4,8 @@ require "graphql/fragment_cache/cache_key_builder"
 
 module GraphQL
   module FragmentCache
+    using Ext
+
     # Represents a single fragment to cache
     class Fragment
       attr_reader :options, :path, :context
@@ -16,10 +18,10 @@ module GraphQL
 
       NIL_IN_CACHE = Object.new
 
-      def read
-        FragmentCache.cache_store.read(cache_key).tap do |cached|
-          return NIL_IN_CACHE if cached.nil? && FragmentCache.cache_store.exist?(cache_key)
-        end
+      def read(keep_in_context = false)
+        return read_from_context { value_from_cache } if keep_in_context
+
+        value_from_cache
       end
 
       def cache_key
@@ -32,6 +34,20 @@ module GraphQL
 
       private
 
+      def read_from_context
+        if (loaded_value = context.loaded_fragments[cache_key])
+          return loaded_value
+        end
+
+        yield.tap { |value| context.loaded_fragments[cache_key] = value }
+      end
+
+      def value_from_cache
+        FragmentCache.cache_store.read(cache_key).tap do |cached|
+          return NIL_IN_CACHE if cached.nil? && FragmentCache.cache_store.exist?(cache_key)
+        end
+      end
+
       def interpreter_context
         context.namespace(:interpreter)
       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
@@ -27,9 +31,10 @@ module GraphQL
         context_to_use = context if context_to_use.nil? && respond_to?(:context)
         raise ArgumentError, "cannot find context, please pass it explicitly" unless context_to_use
 
-        fragment = Fragment.new(context_to_use, options)
+        fragment = Fragment.new(context_to_use, **options)
 
-        if (cached = fragment.read)
+        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
 

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

@@ -6,6 +6,8 @@ module GraphQL
     class CacheKeyBuilder
       def object_key(obj)
         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)
         return obj.map { |item| object_key(item) }.join("/") if obj.is_a?(Array)
         return object_key(obj.to_a) if obj.respond_to?(:to_a)
 

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.1.0"
+    VERSION = "1.5.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-fragment_cache
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.5.0
 platform: ruby
 authors:
 - DmitryTsepelev
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-26 00:00:00.000000000 Z
+date: 2021-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -190,7 +190,7 @@ metadata:
   homepage_uri: https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache
   source_code_uri: https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache
   changelog_uri: https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/CHANGELOG.md
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -205,8 +205,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: Fragment cache for graphql-ruby
 test_files: []