graphql-fragment_cache 0.1.7 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c1bfd3dbaadd053ae1e47ac16d1cb244410adeae3424b30d58b04516447bfe6
-  data.tar.gz: 10de0c52b16423e65db745433a61aef94c795edca3b4b47c3ef834f7118d0a5f
+  metadata.gz: 4a52d1b703c963cd27803c1c28ca0e8c1a66775a84ad8963f88a0e414ec7ed6c
+  data.tar.gz: 4739e71ae750d7fbb8c9366e17da84ad9ae921409308a1b109fc60d8add0557a
 SHA512:
-  metadata.gz: 54ad113a7ef913df0c283c130bae045621dd99298bb1e658e6a4e00440fa29a6ac3d39f45789b49f9cc8a09ddaf34fe4af18560ebbc1c41d73e33d6e539e9b10
-  data.tar.gz: b36091bf683d1018e47ae0fcfd5e69fedad20d4a7b20687a67315d721efa63a5b5df158cb8142ed6342b5ae77c3bd41d08a281299d16f0fcd10d74107e5db78e
+  metadata.gz: 889510e3937c874742624f6da651914ed98c6a996842ec57fcda8121287eead193e12b974247733b38ffc7662e542eb1a82b2fb43d18ef5a121cc41607f811fb
+  data.tar.gz: 4e9dbeb855f55bf37fbe14900b7c4b1b398155902759fd905a87c70da6dfd67850102be48c5b350d6b3126090ced6aaf0bb5b95a7f16a990dd8b070b589e865c

data/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 ## master
 
+## 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][])
+- [PR#31](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/31) Do not patch Connection#wrap in graphql >= 1.10.5 ([@DmitryTsepelev][])
+
+## 1.0.3 (2020-08-31)
+
+- [PR#29](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/29) Cache result JSON instead of connection objects ([@DmitryTsepelev][])
+
+## 1.0.2 (2020-08-19)
+
+- [PR#28](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/28) Support #keys method for GraphQL::FragmentCache::MemoryStore instance ([@reabiliti][])
+
+## 1.0.1 (2020-06-17)
+
+- [PR#25](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/25) Support fragments with aliases for CacheKeyBuilder ([@DmitryTsepelev][])
+
+## 1.0.0 (2020-06-13)
+
+- [PR#24](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/24) Add nil caching. **BREAKING CHANGE**: custom cache stores must also implement `#exist?(key)` method ([@DmitryTsepelev][])
+
 ## 0.1.7 (2020-06-02)
 
 - [PR#23](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/23) Avoid extra queries after restoring connection from cache ([@DmitryTsepelev][])
@@ -39,3 +60,4 @@
 [@DmitryTsepelev]: https://github.com/DmitryTsepelev
 [@palkan]: https://github.com/palkan
 [@ssnickolay]: https://github.com/ssnickolay
+[@reabiliti]: https://github.com/reabiliti

data/README.md

@@ -252,7 +252,7 @@ Rails.application.configure do |config|
 end
 ```
 
-⚠️ Cache store must implement `#read(key)` and `#write(key, value, **options)` methods.
+⚠️ Cache store must implement `#read(key)`, `#write(key, value, **options)` and `#exist?(key)` methods.
 
 The gem provides only in-memory store out-of-the-box (`GraphQL::FragmentCache::MemoryStore`). It's used by default.
 
@@ -275,6 +275,18 @@ class QueryType < BaseObject
 end
 ```
 
+## 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:
+
+```ruby
+field :cached_avatar_url, String, null: false
+
+def cached_avatar_url
+  cache_fragment(query_cache_key: "post_avatar_url(#{object.id})") { object.avatar_url }
+end
+```
+
 ## Credits
 
 Based on the original [gist](https://gist.github.com/palkan/faad9f6ff1db16fcdb1c071ec50e4190) by [@palkan](https://github.com/palkan) and [@ssnickolay](https://github.com/ssnickolay).

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+using RubyNext
+
+module GraphQL
+  module FragmentCache
+    # Memory adapter for storing cached fragments
+    class MemoryStore
+      using RubyNext
+
+      class Entry < Struct.new(:value, :expires_at, keyword_init: true)
+        def expired?
+          expires_at && expires_at < Time.now
+        end
+      end
+
+      attr_reader :default_expires_in
+
+      def initialize(expires_in: nil, **other)
+        raise ArgumentError, "Unsupported options: #{other.keys.join(",")}" unless other.empty?
+
+        @default_expires_in = expires_in
+        @storage = {}
+      end
+
+      def keys
+        storage.keys
+      end
+
+      def exist?(key)
+        storage.key?(key)
+      end
+
+      def read(key)
+        key = key.to_s
+        ((!storage[key].nil?) || nil) && storage[key].then do |entry|
+  if entry.expired?
+    delete(key)
+    next
+  end
+  entry.value
+end
+      end
+
+      def write(key, value, expires_in: default_expires_in, **options)
+        key = key.to_s
+        @storage[key] = Entry.new(value: value, expires_at: expires_in ? Time.now + expires_in : nil)
+      end
+
+      def delete(key)
+        key = key.to_s
+        storage.delete(key)
+      end
+
+      def clear
+        storage.clear
+      end
+
+      private
+
+      attr_reader :storage
+    end
+  end
+end

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

@@ -76,7 +76,13 @@ module GraphQL
 
         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
@@ -115,11 +121,11 @@ module GraphQL
       private
 
       def schema_cache_key
-        @options.fetch(:schema_cache_key, schema.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}]")
+        @options.fetch(:query_cache_key) { "#{path_cache_key}[#{selections_cache_key}]" }
       end
 
       def selections_cache_key

data/lib/graphql/fragment_cache.rb

@@ -6,6 +6,8 @@ require "graphql/fragment_cache/ext/context_fragments"
 require "graphql/fragment_cache/ext/graphql_cache_key"
 require "graphql/fragment_cache/object"
 
+require "graphql/fragment_cache/connections/patch"
+
 require "graphql/fragment_cache/schema/patch"
 require "graphql/fragment_cache/schema/tracer"
 require "graphql/fragment_cache/schema/instrumentation"
@@ -26,6 +28,8 @@ module GraphQL
         schema_defn.tracer(Schema::Tracer)
         schema_defn.instrument(:query, Schema::Instrumentation)
         schema_defn.extend(Schema::Patch)
+
+        GraphQL::Pagination::Connections.prepend(Connections::Patch)
       end
 
       def cache_store=(store)

data/lib/graphql/fragment_cache/cache_key_builder.rb

@@ -76,7 +76,13 @@ module GraphQL
 
         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
@@ -115,11 +121,11 @@ module GraphQL
       private
 
       def schema_cache_key
-        @options.fetch(:schema_cache_key, schema.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}]")
+        @options.fetch(:query_cache_key) { "#{path_cache_key}[#{selections_cache_key}]" }
       end
 
       def selections_cache_key

data/lib/graphql/fragment_cache/connections/patch.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module FragmentCache
+    module Connections
+      # Patches GraphQL::Pagination::Connections to support raw values
+      module Patch
+        if Gem::Dependency.new("graphql", "< 1.11.0").match?("graphql", GraphQL::VERSION)
+          def wrap(field, object, arguments, context, *options)
+            raw_value?(object) ? object : super
+          end
+        elsif Gem::Dependency.new("graphql", "< 1.11.5").match?("graphql", GraphQL::VERSION)
+          def wrap(field, parent, items, arguments, context, *options)
+            raw_value?(items) ? items : super
+          end
+        end
+
+        private
+
+        def raw_value?(value)
+          GraphQL::Execution::Interpreter::RawValue === value
+        end
+      end
+    end
+  end
+end

data/lib/graphql/fragment_cache/fragment.rb

@@ -8,22 +8,22 @@ module GraphQL
     class Fragment
       attr_reader :options, :path, :context
 
-      attr_accessor :resolved_value
-
       def initialize(context, **options)
         @context = context
         @options = options
         @path = interpreter_context[:current_path]
       end
 
+      NIL_IN_CACHE = Object.new
+
       def read
-        FragmentCache.cache_store.read(cache_key)
+        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 persist
-        # Connections are not available from the runtime object, so
-        # we rely on Schema::Tracer to save it for us
-        value = resolved_value || resolve_from_runtime
+        value = final_value.dig(*path)
         FragmentCache.cache_store.write(cache_key, value, **options)
       end
 
@@ -37,10 +37,6 @@ module GraphQL
         context.namespace(:interpreter)
       end
 
-      def resolve_from_runtime
-        final_value.dig(*path)
-      end
-
       def final_value
         @final_value ||= interpreter_context[:runtime].final_value
       end

data/lib/graphql/fragment_cache/memory_store.rb

@@ -23,6 +23,14 @@ module GraphQL
         @storage = {}
       end
 
+      def keys
+        storage.keys
+      end
+
+      def exist?(key)
+        storage.key?(key)
+      end
+
       def read(key)
         key = key.to_s
         storage[key]&.then do |entry|

data/lib/graphql/fragment_cache/object_helpers.rb

@@ -12,8 +12,6 @@ module GraphQL
 
       NO_OBJECT = Object.new
 
-      def_delegator :field, :connection?
-
       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
 
@@ -22,28 +20,13 @@ module GraphQL
         fragment = Fragment.new(context, options)
 
         if (cached = fragment.read)
-          return restore_cached_value(cached)
+          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
         end
       end
-
-      private
-
-      def restore_cached_value(cached)
-        # If we return connection object from resolver, Interpreter stops processing it
-        connection? ? cached : raw_value(cached)
-      end
-
-      def field
-        interpreter_context[:current_field]
-      end
-
-      def interpreter_context
-        @interpreter_context ||= context.namespace(:interpreter)
-      end
     end
   end
 end

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

@@ -10,18 +10,15 @@ module GraphQL
         class << self
           def trace(key, data)
             yield.tap do |resolved_value|
-              next unless connection_to_cache?(key, data)
+              next unless connection_field?(key, data)
 
-              # We need to attach connection object to fragment and save it later
-              context = data[:query].context
-              verify_connections!(context)
-              cache_connection(resolved_value, context)
+              verify_connections!(data[:query].context)
             end
           end
 
           private
 
-          def connection_to_cache?(key, data)
+          def connection_field?(key, data)
             key == "execute_field" && data[:field].connection?
           end
 
@@ -31,12 +28,6 @@ module GraphQL
             raise StandardError,
               "GraphQL::Pagination::Connections should be enabled for connection caching"
           end
-
-          def cache_connection(resolved_value, context)
-            current_path = context.namespace(:interpreter)[:current_path]
-            fragment = context.fragments.find { |fragment| fragment.path == current_path }
-            fragment.resolved_value = resolved_value if fragment
-          end
         end
       end
     end

data/lib/graphql/fragment_cache/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-fragment_cache
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 1.0.4
 platform: ruby
 authors:
 - DmitryTsepelev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-02 00:00:00.000000000 Z
+date: 2020-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: 0.10.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: 0.10.0
 - !ruby/object:Gem::Dependency
   name: combustion
   requirement: !ruby/object:Gem::Requirement
@@ -128,14 +128,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '0.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: unparser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.9
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.9
 description: Fragment cache for graphql-ruby
 email:
 - dmitry.a.tsepelev@gmail.com
@@ -148,12 +162,14 @@ files:
 - README.md
 - bin/console
 - bin/setup
+- 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
 - lib/graphql-fragment_cache.rb
 - lib/graphql/fragment_cache.rb
 - lib/graphql/fragment_cache/cache_key_builder.rb
 - lib/graphql/fragment_cache/cacher.rb
+- lib/graphql/fragment_cache/connections/patch.rb
 - lib/graphql/fragment_cache/ext/context_fragments.rb
 - lib/graphql/fragment_cache/ext/graphql_cache_key.rb
 - lib/graphql/fragment_cache/field_extension.rb