graphql-result_cache 0.1.5 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6cae5e83e05f6aae4a8ac2c26a6d2077d25c7fa32176234f347b0e8273a6ee3e
-  data.tar.gz: 77fb9355094bb37c82991a935e2f91058b7e2b7f93510c8037665a1f88df13d3
+  metadata.gz: 535b29453885101a889e6228ded5fd20a83dd6e09f104fc3e9f369e1324b2d28
+  data.tar.gz: e8bad278755e2357bd12aa64ecf3e6078f307ede91625e21ed6794f5e6731144
 SHA512:
-  metadata.gz: caf21c2c2c7f4bdf29f714376f4867390f3b8f8ff894692d918574a300820abead72a13c8e321c67097381d5ffabc0b6c6de8bbfe95bb7d136e4d0fbd43e0c49
-  data.tar.gz: 35677cba82ea49aaf9bd94aa059249f80d6ef9caf35476a6edc418012d7467f1f53d52b0bd48ca3a73d428d4be362473f8cf05cec98d660f1f4b3a2d47fc5ffd
+  metadata.gz: 329163b7405a290722f3e594548eaebf459dbfd01d0a5727030b6272043088dc99b2a3acf455b9f40fa4174084b4f37bb17db3da767862ef457ef7a6d8fe2592
+  data.tar.gz: 34dcf33d3e285be6f08c94eba94ea10845f7204eb3fc6247744e16c0377c6ff6f13d75c83f79d17bc247094fc1cf468492a21432f1c72e246e82dc660165d6cd

data/.github/workflows/ruby.yml

@@ -0,0 +1,31 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
+# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
+
+name: Ruby
+
+on: [push, pull_request]
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['2.5', '2.6', '2.7']
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+    # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
+    # change this to (see https://github.com/ruby/setup-ruby#versioning):
+    # uses: ruby/setup-ruby@v1
+      uses: ruby/setup-ruby@473e4d8fe5dd94ee328fdfca9f8c9c7afc9dae5e
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - name: Run tests
+      run: bundle exec rspec

data/.gitignore

@@ -6,5 +6,7 @@
 /pkg/
 /spec/reports/
 /tmp/
+/tags
 
-/.idea/
+/.idea/
+/graphql-result_cache-*.gem

data/Gemfile.lock

@@ -1,37 +1,37 @@
 PATH
   remote: .
   specs:
-    graphql-result_cache (0.1.4)
-      graphql (~> 1.9)
+    graphql-result_cache (1.0.0)
+      graphql (~> 1.10)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    diff-lcs (1.3)
-    graphql (1.9.9)
-    rake (10.5.0)
-    rspec (3.8.0)
-      rspec-core (~> 3.8.0)
-      rspec-expectations (~> 3.8.0)
-      rspec-mocks (~> 3.8.0)
-    rspec-core (3.8.2)
-      rspec-support (~> 3.8.0)
-    rspec-expectations (3.8.4)
+    diff-lcs (1.4.4)
+    graphql (1.12.20)
+    rake (12.3.3)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-mocks (3.8.1)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-support (3.8.2)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.3)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  bundler (~> 1.16)
+  bundler (~> 2.2, >= 2.2.10)
   graphql-result_cache!
-  rake (~> 10.0)
-  rspec (~> 3.0)
+  rake (~> 12.3, >= 12.3.3)
+  rspec (~> 3.10)
 
 BUNDLED WITH
-   1.17.3
+   2.2.31

data/README.md

@@ -2,6 +2,8 @@
 
 This gem is to cache the json result, instead of resolved object.
 
+If you are using `graphql < 1.10.0` or without `GraphQL::Execution::Interpreter`, please [read this](https://github.com/saharaying/graphql-result_cache/wiki/GraphQL::ResultCache-(v0.1.x)).
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -21,65 +23,57 @@ Or install it yourself as:
 ## Usage
 
 1. Use `GraphQL::ResultCache` as a plugin in your schema.
- 
+
 ```ruby
 class MySchema < GraphQL::Schema
+  # Default value for graphql v1.12.x
+  use GraphQL::Execution::Interpreter
+  use GraphQL::Analysis::AST
+
+  introspection GraphQL::ResultCache::Introspection
+
   mutation Types::MutationType
   query Types::QueryType
- 
+
   use GraphQL::ResultCache
 end
 ```
 
-2. Add the custom field class to accept `result_cache` metadata.
+2. Add the custom field class to accept `result_cache` definition.
 
 ```ruby
 module Types
   class BaseObject < GraphQL::Schema::Object
-    field_class GraphQL::ResultCache::Field
+    field_class GraphQL::ResultCache::Schema::Field
   end
 end
 ```
 
-3. Config the fields which need to be cached with `result_cache` definition.
+3. Config the fields which need to be cached.
 
 ```ruby
 field :theme, Types::ThemeType, null: false, result_cache: true
 ```
 
-4. Wrap query result with `GraphQL::ResultCache::Result`.
-
-```ruby
-class GraphqlController < ApplicationController
-  def execute
-    # ...
-    result = if params[:_json]
-               multiple_execute(params[:_json], context: context)
-             else
-               execute_query(context: context)
-             end
-    render json: GraphQL::ResultCache::Result.new(result)
-  end
-end
-```
-
 ## Result Cache Customization
 
 ### Cache condition
 
+The `if` condition can be either a Symbol or a Proc.
+
 ```ruby
 field :theme, Types::ThemeType, null: false, result_cache: { if: :published? }
 ```
-The `if` condition can be either a Symbol or a Proc.
 
 ### Customized cache key
 
-By default, `GraphQL::ResultCache` will generate a cache key combining the field path, arguments and object. 
+By default, `GraphQL::ResultCache` will generate a cache key combining the field path, arguments and object.
 But you can customize the object clause by specify the `key` option.
 
 ```ruby
 field :theme, Types::ThemeType, null: false, result_cache: { key: :theme_cache_key }
 ```
+
 The `key` can be either a Symbol or a Proc.
 
 ### Callback after cached result applied
@@ -105,6 +99,7 @@ GraphQL::ResultCache.configure do |config|
   config.namespace   = "GraphQL:Result"                         # Cache key namespace
   config.expires_in  = 1.hour                                   # Expire time for the cache, default to 1.hour
   config.client_hash = -> { Rails.cache.read(:deploy_version) } # GraphQL client package hash key, used in cache key generation, default to nil
+  config.except = ->(ctx) { !ctx[:result_cacheable] }           # Exception rule, skip the cache while evaluated as true, default to nil
   config.cache       = Rails.cache                              # The cache object, default to Rails.cache in Rails
   config.logger      = Rails.logger                             # The Logger, default to Rails.logger in Rails
 end
@@ -113,7 +108,7 @@ end
 When using with introspection, you need to assign custom introspection to avoid getting the nullable type for a non-null type.
 ```ruby
 class MySchema < GraphQL::Schema
-  introspection ::GraphQL::ResultCache::Introspection
+  introspection GraphQL::ResultCache::Introspection
 end
 ```
 

data/graphql-result_cache.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.email         = ['saharaying@gmail.com']
 
   spec.summary       = 'A result caching plugin for graphql-ruby'
-  spec.description   = 'A result caching plugin for graphql-ruby'
+  spec.description   = 'This gem is to cache the json result, instead of resolved object.'
   spec.homepage      = 'https://github.com/saharaying/graphql-result_cache'
   spec.license       = 'MIT'
 
@@ -19,11 +19,11 @@ Gem::Specification.new do |spec|
   end
   spec.require_paths = ['lib']
 
-  spec.add_development_dependency 'bundler', '~> 1.16'
-  spec.add_development_dependency 'rake', '~> 10.0'
-  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'bundler', '~> 2.2', '>= 2.2.10'
+  spec.add_development_dependency 'rake', '~> 12.3', '>= 12.3.3'
+  spec.add_development_dependency 'rspec', '~> 3.10'
 
-  spec.add_dependency 'graphql', '~> 1.9'
+  spec.add_dependency 'graphql', '~> 1.10'
 
   # graphql v1.9 requires ruby >= 2.2.0
   spec.required_ruby_version = '>= 2.2.0'

data/lib/graphql/result_cache/callback.rb

@@ -1,21 +1,27 @@
 module GraphQL
   module ResultCache
     class Callback
-      def initialize obj:, args:, ctx:, value:
+      def initialize(obj:, args:, ctx:, value:)
         @obj = obj
         @args = args
         @ctx = ctx
         @value = value
       end
 
-      def call result_hash
+      def call(result_hash)
         case @value
           when Symbol
             @obj.public_send(@value, result_hash)
           when Proc
             @value.call(result_hash, @obj, @args, @ctx)
         end
-        ::GraphQL::ResultCache.logger && ::GraphQL::ResultCache.logger.debug("GraphQL result cache callback called for #{@ctx.path.join('.')}")
+        ::GraphQL::ResultCache.logger && ::GraphQL::ResultCache.logger.debug("GraphQL result cache callback called for #{ctx_path}")
+      end
+
+      private
+
+      def ctx_path
+        @ctx.namespace(:interpreter)[:current_path].join('.')
       end
     end
   end

data/lib/graphql/result_cache/condition.rb

@@ -9,15 +9,23 @@ module GraphQL
       end
 
       def true?
+        return false if except?
         case @if
-          when Symbol
-            @obj.send(@if)
-          when Proc
-            @if.call(@obj, @args, @ctx)
-          else
-            true
+        when Symbol
+          @obj.send(@if)
+        when Proc
+          @if.call(@obj, @args, @ctx)
+        else
+          true
         end
       end
+
+      private
+
+      def except?
+        except = ::GraphQL::ResultCache.except
+        except.is_a?(Proc) ? except.call(@ctx) : except
+      end
     end
   end
 end

data/lib/graphql/result_cache/context_config.rb

@@ -8,16 +8,16 @@ module GraphQL
         @value = {}
       end
 
-      def add context:, key:, after_process: nil
-        @value[context.query] ||= []
+      def add query:, path:, key:, after_process: nil
+        @value[query] ||= []
         cached = cache.exist? key
         logger && logger.info("GraphQL result cache key #{cached ? 'hit' : 'miss'}: #{key}")
-        config_value = { path: context.path, key: key }
+        config_value = { path: path, key: key }
         if cached
           config_value[:result] = cache.read(key)
           config_value[:after_process] = after_process if after_process
         end
-        @value[context.query] << config_value
+        @value[query] << config_value
         cached
       end
 
@@ -39,7 +39,7 @@ module GraphQL
       def cache_or_amend_result result, config_of_query
         config_of_query.each do |config|
           if config[:result].nil?
-            cache.write config[:key], result.dig('data', *config[:path]), cache_write_options.merge(expires_in: expires_in)
+            cache.write config[:key], dig(result, 'data', *config[:path]), cache_write_options.merge(expires_in: expires_in)
           else
             # result already got from cache, need to amend to response
             result_hash = result.to_h

data/lib/graphql/result_cache/introspection/field_type.rb

@@ -4,7 +4,8 @@ module GraphQL
       class FieldType < ::GraphQL::Introspection::FieldType
 
         def type
-          @object.metadata[:original_non_null] && !@object.type.non_null? ? @object.type.to_non_null_type : @object.type
+          return @object.type unless @object.respond_to?(:original_return_type_not_null)
+          @object.original_return_type_not_null && !@object.type.non_null? ? @object.type.to_non_null_type : @object.type
         end
 
       end

data/lib/graphql/result_cache/key.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module GraphQL
   module ResultCache
     class Key
-      def initialize obj:, args:, ctx:, key: nil
+      def initialize(obj:, args:, ctx: nil, key: nil)
         @obj = obj
         @args = args
         @ctx = ctx
@@ -21,7 +23,7 @@ module GraphQL
       private
 
       def path_clause
-        @ctx.path.join('.')
+        @ctx.namespace(:interpreter)[:current_path].join('.') unless @ctx.nil?
       end
 
       def args_clause
@@ -53,7 +55,6 @@ module GraphQL
         return object.id if object.respond_to?(:id)
         object.object_id
       end
-
     end
   end
-end
+end

data/lib/graphql/result_cache/result.rb

@@ -1,27 +1,24 @@
 module GraphQL
   module ResultCache
     class Result
-      extend Forwardable
-
-      attr_reader :value
-
-      def_delegators :@value, :to_json, :as_json
-
       def initialize query_result
         @_result = query_result
-        @value = process_with_result_cache
+      end
+
+      def process!
+        process_with_result_cache
       end
 
       private
 
       def process_with_result_cache
         return process_each(@_result) unless @_result.is_a?(Array)
-        @_result.map { |result| process_each(result) }
+        @_result.each { |result| process_each(result) }
       end
 
       def process_each result
         result_cache_config = result.query.context[:result_cache]
-        blank?(result_cache_config) ? result : result_cache_config.process(result)
+        result_cache_config.process(result) unless blank?(result_cache_config)
       end
 
       def blank? obj

data/lib/graphql/result_cache/schema/field.rb

@@ -0,0 +1,19 @@
+module GraphQL
+  module ResultCache
+    module Schema
+      class Field < ::GraphQL::Schema::Field
+        attr_reader :original_return_type_not_null
+
+        def initialize(*args, result_cache: nil, **kwargs, &block)
+          super(*args, **kwargs, &block)
+          return unless result_cache
+          unless @return_type_null
+            @original_return_type_not_null = true
+            @return_type_null = true
+          end
+          extension FieldExtension, result_cache
+        end
+      end
+    end
+  end
+end

data/lib/graphql/result_cache/schema/field_extension.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'graphql/result_cache/condition'
+require 'graphql/result_cache/context_config'
+require 'graphql/result_cache/key'
+require 'graphql/result_cache/callback'
+
+module GraphQL
+  module ResultCache
+    module Schema
+      class FieldExtension < GraphQL::Schema::FieldExtension
+        def resolve(object:, arguments:, context:)
+          cache_config = options.respond_to?(:to_h) ? options.to_h : {}
+
+          if Condition.new(cache_config, obj: object, args: arguments, ctx: context).true?
+            context[:result_cache] ||= ContextConfig.new
+            cached = add_to_context_result_cache(context, object, arguments, cache_config)
+          end
+
+          yield(object, arguments) unless cached
+        end
+
+        private
+
+        def add_to_context_result_cache(context, object, arguments, cache_config)
+          cache_key = key(object, arguments, context, cache_config)
+          after_process = after_process(object, arguments, context, cache_config)
+          context[:result_cache].add(
+            query: context.query,
+            path: context.namespace(:interpreter)[:current_path],
+            key: cache_key.to_s,
+            after_process: after_process
+          )
+        end
+
+        def key(object, arguments, context, config)
+          Key.new(
+            obj: object,
+            args: arguments,
+            ctx: context,
+            key: config[:key]
+          )
+        end
+
+        def after_process(object, arguments, context, config)
+          return unless config[:after_process]
+
+          Callback.new(
+            obj: object,
+            args: arguments,
+            ctx: context,
+            value: config[:after_process]
+          )
+        end
+      end
+    end
+  end
+end

data/lib/graphql/result_cache/schema/query_instrument.rb

@@ -0,0 +1,15 @@
+module GraphQL
+  module ResultCache
+    module Schema
+      module QueryInstrument
+        module_function
+
+        def before_query(_query) end
+
+        def after_query(query)
+          GraphQL::ResultCache::Result.new(query.result).process!
+        end
+      end
+    end
+  end
+end

data/lib/graphql/result_cache/version.rb

@@ -1,5 +1,5 @@
 module GraphQL
   module ResultCache
-    VERSION = '0.1.5'
+    VERSION = '1.0.0'
   end
 end

data/lib/graphql/result_cache.rb

@@ -1,8 +1,9 @@
 require 'graphql'
 require 'graphql/result_cache/version'
-require 'graphql/result_cache/field'
 require 'graphql/result_cache/result'
-require 'graphql/result_cache/field_instrument'
+require 'graphql/result_cache/schema/field'
+require 'graphql/result_cache/schema/field_extension'
+require 'graphql/result_cache/schema/query_instrument'
 require 'graphql/result_cache/introspection'
 
 module GraphQL
@@ -18,6 +19,9 @@ module GraphQL
       # c.client_hash = -> { Rails.cache.read(:deploy_version) }
       attr_accessor :client_hash
 
+      # global condition, skip the cache when the value is true, should be a proc.
+      attr_accessor :except
+
       # ```
       # GraphQL::ResultCache.configure do |c|
       #   c.namespace = "GraphQL:Result"
@@ -28,16 +32,19 @@ module GraphQL
       def configure
         yield self
       end
+
+      def use(schema_def)
+        return schema_def.instrument(:query, Schema::QueryInstrument) if schema_def.interpreter?
+        raise 'Please use the graphql gem version >= 1.10 with GraphQL::Execution::Interpreter'
+      end
     end
 
     # Default configuration
-    @expires_in = 3600              # 1.hour
+    @expires_in = 3600 # 1.hour
     @namespace = 'GraphQL:Result'
-
-    def self.use(schema_def, options: {})
-      schema_def.instrument(:field, ::GraphQL::ResultCache::FieldInstrument.new)
-    end
   end
 end
 
+GraphQL::Schema::Field.accepts_definition(:result_cache)
+
 require 'graphql/result_cache/rails' if defined?(::Rails::Engine)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-result_cache
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 1.0.0
 platform: ruby
 authors:
 - Ying Fu
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-14 00:00:00.000000000 Z
+date: 2021-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,63 +16,76 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '2.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.10
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '2.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.10
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.3.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.3.3
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.10'
 - !ruby/object:Gem::Dependency
   name: graphql
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.9'
+        version: '1.10'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.9'
-description: A result caching plugin for graphql-ruby
+        version: '1.10'
+description: This gem is to cache the json result, instead of resolved object.
 email:
 - saharaying@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".rspec"
 - CODE_OF_CONDUCT.md
@@ -88,13 +101,14 @@ files:
 - lib/graphql/result_cache/callback.rb
 - lib/graphql/result_cache/condition.rb
 - lib/graphql/result_cache/context_config.rb
-- lib/graphql/result_cache/field.rb
-- lib/graphql/result_cache/field_instrument.rb
 - lib/graphql/result_cache/introspection.rb
 - lib/graphql/result_cache/introspection/field_type.rb
 - lib/graphql/result_cache/key.rb
 - lib/graphql/result_cache/rails.rb
 - lib/graphql/result_cache/result.rb
+- lib/graphql/result_cache/schema/field.rb
+- lib/graphql/result_cache/schema/field_extension.rb
+- lib/graphql/result_cache/schema/query_instrument.rb
 - lib/graphql/result_cache/version.rb
 homepage: https://github.com/saharaying/graphql-result_cache
 licenses:

data/lib/graphql/result_cache/field.rb

@@ -1,17 +0,0 @@
-module GraphQL
-  module ResultCache
-    class Field < ::GraphQL::Schema::Field
-      def initialize(*args, result_cache: nil, **kwargs, &block)
-        @result_cache_config = result_cache
-        super(*args, **kwargs, &block)
-      end
-
-      def to_graphql
-        field_defn = super # Returns a GraphQL::Field
-        field_defn.metadata[:result_cache] = @result_cache_config
-        field_defn.metadata[:original_non_null] = true if @result_cache_config && field_defn.type.non_null?
-        field_defn
-      end
-    end
-  end
-end

data/lib/graphql/result_cache/field_instrument.rb

@@ -1,37 +0,0 @@
-require 'graphql/result_cache/condition'
-require 'graphql/result_cache/context_config'
-require 'graphql/result_cache/key'
-require 'graphql/result_cache/callback'
-
-module GraphQL
-  module ResultCache
-    class FieldInstrument
-      def instrument _type, field
-        return field unless field.metadata[:result_cache]
-
-        cached_resolve_proc = cached_resolve(field)
-        field.redefine do
-          resolve(cached_resolve_proc)
-          type(field.type.of_type) if field.type.non_null?
-        end
-      end
-
-      private
-
-      def cached_resolve field
-        old_resolve_proc = field.resolve_proc
-        cache_config = field.metadata[:result_cache]
-        cache_config = {} unless cache_config.is_a?(Hash)
-        lambda do |obj, args, ctx|
-          if Condition.new(cache_config, obj: obj, args: args, ctx: ctx).true?
-            ctx[:result_cache] ||= ContextConfig.new
-            cache_key = Key.new(obj: obj, args: args, ctx: ctx, key: cache_config[:key])
-            after_process = Callback.new(obj: obj, args: args, ctx: ctx, value: cache_config[:after_process]) if cache_config[:after_process]
-            cached = ctx[:result_cache].add context: ctx, key: cache_key.to_s, after_process: after_process
-          end
-          old_resolve_proc.call(obj, args, ctx) unless cached
-        end
-      end
-    end
-  end
-end