Refactor resolving proc into legit class

Author: thebadmonkeydev

lib/graphql/cache/fetcher.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require 'graphql/cache/resolver'
+
 module GraphQL
   module Cache
     # Represents the "instrumenter" passed to GraphQL::Schema#instrument
@@ -14,58 +18,7 @@ class Fetcher
       def instrument(type, field)
         return field unless field.metadata[:cache]
 
-        cached_resolve_proc = cached_resolve(type, field)
-
-        # Return a copy of `field`, with the new resolve proc
-        field.redefine { resolve(cached_resolve_proc) }
-      end
-
-      # @private
-      def cache_key(obj, args, type, field, ctx)
-        Key.new(obj, args, type, field, ctx).to_s
-      end
-
-      # @private
-      def cached_resolve(type, field)
-        old_resolve_proc = field.resolve_proc
-
-        lambda do |obj, args, ctx|
-          key = cache_key(obj, args, type, field, ctx)
-
-          value = Marshal[key].read(
-            field.metadata[:cache], force: ctx[:force_cache]
-          ) do
-            old_resolve_proc.call(obj, args, ctx)
-          end
-
-          wrap_connections(value, args, field: field, parent: obj, context: ctx)
-        end
-      end
-
-      # @private
-      def wrap_connections(value, args, **kwargs)
-        # return raw value if field isn't a connection (no need to wrap)
-        return value unless kwargs[:field].connection?
-
-        # return cached value if it is already a connection object
-        # this occurs when the value is being resolved by GraphQL
-        # and not being read from cache
-        return value if value.class.ancestors.include?(
-          GraphQL::Relay::BaseConnection
-        )
-
-        create_connection(value, args, **kwargs)
-      end
-
-      # @private
-      def create_connection(value, args, **kwargs)
-        GraphQL::Relay::BaseConnection.connection_for_nodes(value).new(
-          value,
-          args,
-          field: kwargs[:field],
-          parent: kwargs[:parent],
-          context: kwargs[:context]
-        )
+        field.redefine { resolve(GraphQL::Cache::Resolver.new(type, field)) }
       end
     end
   end

lib/graphql/cache/resolver.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Cache
+    # Represents the caching resolver that wraps the existing resolver proc
+    class Resolver
+      attr_accessor :type
+
+      attr_accessor :field
+
+      attr_accessor :orig_resolve_proc
+
+      def initialize(type, field)
+        @type  = type
+        @field = field
+      end
+
+      def call(obj, args, ctx)
+        @orig_resolve_proc = field.resolve_proc
+
+        key = cache_key(obj, args, ctx)
+
+        value = Marshal[key].read(
+          field.metadata[:cache], force: ctx[:force_cache]
+        ) do
+          @orig_resolve_proc.call(obj, args, ctx)
+        end
+
+        wrap_connections(value, args, parent: obj, context: ctx)
+      end
+
+      protected
+
+      # @private
+      def cache_key(obj, args, ctx)
+        Key.new(obj, args, type, field, ctx).to_s
+      end
+
+      # @private
+      def wrap_connections(value, args, **kwargs)
+        # return raw value if field isn't a connection (no need to wrap)
+        return value unless field.connection?
+
+        # return cached value if it is already a connection object
+        # this occurs when the value is being resolved by GraphQL
+        # and not being read from cache
+        return value if value.class.ancestors.include?(
+          GraphQL::Relay::BaseConnection
+        )
+
+        create_connection(value, args, **kwargs)
+      end
+
+      # @private
+      def create_connection(value, args, **kwargs)
+        GraphQL::Relay::BaseConnection.connection_for_nodes(value).new(
+          value,
+          args,
+          field: field,
+          parent: kwargs[:parent],
+          context: kwargs[:context]
+        )
+      end
+    end
+  end
+end