Cache result JSON instead of connection objects (#29)

Author: DmitryTsepelev

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## master
 
+- [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][])

lib/graphql/fragment_cache.rb

@@ -6,6 +6,8 @@
 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 @@ def use(schema_defn, options = {})
         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)

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, parent, items, arguments, context, *options)
+            raw_value?(items) ? items : super
+          end
+        else
+          def wrap(field, object, arguments, context, *options)
+            raw_value?(object) ? object : super
+          end
+        end
+
+        private
+
+        def raw_value?(value)
+          GraphQL::Execution::Interpreter::RawValue === value
+        end
+      end
+    end
+  end
+end

lib/graphql/fragment_cache/fragment.rb

@@ -8,8 +8,6 @@ module FragmentCache
     class Fragment
       attr_reader :options, :path, :context
 
-      attr_accessor :resolved_value
-
       def initialize(context, **options)
         @context = context
         @options = options
@@ -25,9 +23,7 @@ def read
       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
 
@@ -41,10 +37,6 @@ def interpreter_context
         context.namespace(:interpreter)
       end
 
-      def resolve_from_runtime
-        final_value.dig(*path)
-      end
-
       def final_value
         @final_value ||= interpreter_context[:runtime].final_value
       end

lib/graphql/fragment_cache/object_helpers.rb

@@ -22,8 +22,7 @@ def cache_fragment(object_to_cache = NO_OBJECT, **options, &block)
         fragment = Fragment.new(context, options)
 
         if (cached = fragment.read)
-          return nil if cached == Fragment::NIL_IN_CACHE
-          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|
@@ -33,11 +32,6 @@ def cache_fragment(object_to_cache = NO_OBJECT, **options, &block)
 
       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

lib/graphql/fragment_cache/schema/tracer.rb

@@ -10,18 +10,15 @@ class Tracer
         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 @@ def verify_connections!(context)
             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