graphql-fragment_cache 1.0.4 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a52d1b703c963cd27803c1c28ca0e8c1a66775a84ad8963f88a0e414ec7ed6c
-  data.tar.gz: 4739e71ae750d7fbb8c9366e17da84ad9ae921409308a1b109fc60d8add0557a
+  metadata.gz: dab2cb1f4c27251da27c938bd8a0392f3ad0edcb5c54ba1d7d83d9e2f9c4b12b
+  data.tar.gz: 8e5323ed6bf476d185c993b8165e292d4d7e70df56fa1ae1ad32da2ae7bc0880
 SHA512:
-  metadata.gz: 889510e3937c874742624f6da651914ed98c6a996842ec57fcda8121287eead193e12b974247733b38ffc7662e542eb1a82b2fb43d18ef5a121cc41607f811fb
-  data.tar.gz: 4e9dbeb855f55bf37fbe14900b7c4b1b398155902759fd905a87c70da6dfd67850102be48c5b350d6b3126090ced6aaf0bb5b95a7f16a990dd8b070b589e865c
+  metadata.gz: 90eebb6973db225980926d330d93ca70a50768279bb727cf702f1bd905628cf7969e1af5025a6fefb1f9785d1fc008fd560d236fbe6315821a6dd2f92243ef56
+  data.tar.gz: b26090f37a4b20ce45a256880b708c17a77871d8e8f5d95c1b34f171062306332f1bf9a549ab92bce5a326a2327d5b8a4f8106e2b2b4ac338bbd257cec8e6a21

data/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 ## master
 
+## 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][])
+
+## 1.0.5 (2020-10-13)
+
+- [PR#35](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/35) Prefer using `#write_multi` on cache store when possible ([@DmitryTsepelev][])
+
 ## 1.0.4 (2020-10-12)
 
 - [PR#34](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/34) Avoid unneded default calculation in CacheKeyBuilder ([@DmitryTsepelev][])
@@ -61,3 +81,4 @@
 [@palkan]: https://github.com/palkan
 [@ssnickolay]: https://github.com/ssnickolay
 [@reabiliti]: https://github.com/reabiliti
+[@bbugh]: https://github.com/bbugh

data/README.md

@@ -38,6 +38,14 @@ class BaseType < GraphQL::Schema::Object
 end
 ```
 
+If you're using [resolvers](https://graphql-ruby.org/fields/resolvers.html) — include the module into the base resolver as well:
+
+```ruby
+class Resolvers::BaseResolver < GraphQL::Schema::Resolver
+  include GraphQL::FragmentCache::ObjectHelpers
+end
+```
+
 Now you can add `cache_fragment:` option to your fields to turn caching on:
 
 ```ruby
@@ -47,7 +55,7 @@ class PostType < BaseObject
 end
 ```
 
-Alternatively, you can use `cache_fragment` method inside resolvers:
+Alternatively, you can use `cache_fragment` method inside resolver methods:
 
 ```ruby
 class QueryType < BaseObject
@@ -107,7 +115,7 @@ query_cache_key = Digest::SHA1.hexdigest("#{path_cache_key}#{selections_cache_ke
 cache_key = "#{schema_cache_key}/#{query_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` or `path_cache_key` by passing parameters to the `cache_fragment` calls:
 
 ```ruby
 class QueryType < BaseObject
@@ -121,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
@@ -252,7 +262,7 @@ Rails.application.configure do |config|
 end
 ```
 
-⚠️ Cache store must implement `#read(key)`, `#write(key, value, **options)` and `#exist?(key)` methods.
+⚠️ Cache store must implement `#read(key)`, `#exist?(key)` and `#write_multi(hash, **options)` or `#write(key, value, **options)` methods.
 
 The gem provides only in-memory store out-of-the-box (`GraphQL::FragmentCache::MemoryStore`). It's used by default.
 
@@ -275,6 +285,53 @@ class QueryType < BaseObject
 end
 ```
 
+## How to use `#cache_fragment` in extensions (and other places where context is not available)
+
+If you want to call `#cache_fragment` from places other that fields or resolvers, you'll need to pass `context` explicitly and turn on `raw_value` support. For instance, let's take a look at this extension:
+
+```ruby
+class Types::QueryType < Types::BaseObject
+  class CurrentMomentExtension < GraphQL::Schema::FieldExtension
+    # turning on cache_fragment support
+    include GraphQL::FragmentCache::ObjectHelpers
+
+    def resolve(object:, arguments:, context:)
+      # context is passed explicitly
+      cache_fragment(context: context) do
+        result = yield(object, arguments)
+        "#{result} (at #{Time.now})"
+      end
+    end
+  end
+
+  field :event, String, null: false, extensions: [CurrentMomentExtension]
+
+  def event
+    "something happened"
+  end
+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

@@ -141,20 +141,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/cache_key_builder.rb

@@ -141,20 +141,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/cacher.rb

@@ -10,7 +10,26 @@ module GraphQL
         def call(query)
           return unless query.context.fragments?
 
-          query.context.fragments.each(&:persist)
+          if FragmentCache.cache_store.respond_to?(:write_multi)
+            batched_persist(query)
+          else
+            persist(query)
+          end
+        end
+
+        private
+
+        def batched_persist(query)
+          query.context.fragments.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|
+            FragmentCache.cache_store.write(fragment.cache_key, fragment.value, **fragment.options)
+          end
         end
       end
     end

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,21 +18,34 @@ 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
+        @cache_key ||= CacheKeyBuilder.call(path: path, query: context.query, **options)
       end
 
-      def persist
-        value = final_value.dig(*path)
-        FragmentCache.cache_store.write(cache_key, value, **options)
+      def value
+        final_value.dig(*path)
       end
 
       private
 
-      def cache_key
-        @cache_key ||= CacheKeyBuilder.call(path: path, query: context.query, **options)
+      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

data/lib/graphql/fragment_cache/object_helpers.rb

@@ -10,6 +10,12 @@ module GraphQL
     module ObjectHelpers
       extend Forwardable
 
+      def self.included(base)
+        return if base < GraphQL::Execution::Interpreter::HandlesRawValue
+
+        base.include(GraphQL::Execution::Interpreter::HandlesRawValue)
+      end
+
       NO_OBJECT = Object.new
 
       def cache_fragment(object_to_cache = NO_OBJECT, **options, &block)
@@ -17,14 +23,19 @@ module GraphQL
 
         options[:object] = object_to_cache if object_to_cache != NO_OBJECT
 
-        fragment = Fragment.new(context, options)
+        context_to_use = options.delete(:context)
+        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)
 
-        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
 
         (block_given? ? block.call : object_to_cache).tap do |resolved_value|
-          context.fragments << fragment
+          context_to_use.fragments << fragment
         end
       end
     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/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module FragmentCache
-    VERSION = "1.0.4"
+    VERSION = "1.4.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-fragment_cache
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.4.0
 platform: ruby
 authors:
 - DmitryTsepelev
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-12 00:00:00.000000000 Z
+date: 2020-12-03 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: []