graphql-fragment_cache 0.1.4 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f5ab2d2bd11b30a0c40476378f1b9ad0c064ccffec7f4595f9d81dbb0ad85eac
-  data.tar.gz: 44c09dce73b8836f656f186291ed4a45b9cdab6c0ed8844dea38bb9fe9b276bc
+  metadata.gz: 760e0c3b18dc1081e3f7a2d1534087e1cc827b790c919ed2e4a9619777bd1ae7
+  data.tar.gz: 94a9b27d60ef3dbf0e69d13947fadd247c628da22dacde4e84323e69366e68f1
 SHA512:
-  metadata.gz: c225d6650aa383253eda036366f92d9a9ae2109c873cc9f4f69e9b736367c31c9c7b0c59c42ad830f4554184af75016239a0c3a739d2e3f1b4621fcbed9814e1
-  data.tar.gz: 556d2eced9aef328be63f06de9404e78e958a06f5cba2394c1fda4d449c63d04399730978767a40a7b4544b41418f1bab96384aafddd819cd4c6bbad79b62af0
+  metadata.gz: afc55177d8c5b14ad4d1f5f95cf69c8dd499e43408205d4797b3f82068144cb39d63f200799b4e5dba13925055009527ef8515f3108b1dc98854377d1f26d9bf
+  data.tar.gz: c9da2cb81cd250f92984c732facf1c6fe62bd45f9161a4e38a28eb5a9e90c167baf74278af80eaf15edb53992df9b00e476f935e421404f5939d3b19cc45101c

data/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 ## master
 
+## 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][])
+
+## 0.1.6 (2020-05-30)
+
+- [PR#22](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/22) Properly cache entites inside collections ([@DmitryTsepelev][])
+
+## 0.1.5 (2020-04-28)
+
+- [PR#19](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/19) Add connections support ([@DmitryTsepelev][])
+- [PR#18](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/18) Support aliases in cache key generation ([@palkan][], [@DmitryTsepelev][])
+
 ## 0.1.4 (2020-04-25)
 
 - Fix railtie to set up null store for tests ([@DmitryTsepelev][])

data/README.md

@@ -61,6 +61,15 @@ class QueryType < BaseObject
 end
 ```
 
+If you use [connections](https://graphql-ruby.org/pagination/connection_concepts.html) and plan to cache them—please turn on [brand new](https://github.com/rmosolgo/graphql-ruby/blob/master/lib/graphql/pagination/connections.rb#L5) connections hierarchy in your schema:
+
+```ruby
+class GraphqSchema < GraphQL::Schema
+  # ...
+  use GraphQL::Pagination::Connections
+end
+```
+
 ## Cache key generation
 
 Cache keys consist of implicit and explicit (provided by user) parts.
@@ -243,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.
 
@@ -266,10 +275,6 @@ class QueryType < BaseObject
 end
 ```
 
-## Limitations
-
-- [Field aliases](https://spec.graphql.org/June2018/#sec-Field-Alias) are not currently supported (take a look at the failing spec [here](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/7))
-
 ## 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.7/graphql/fragment_cache/cache_key_builder.rb

@@ -18,6 +18,77 @@ module GraphQL
           }.join(".")
         end
       end
+
+      refine ::GraphQL::Language::Nodes::AbstractNode do
+        def alias?(_)
+          false
+        end
+      end
+
+      refine ::GraphQL::Language::Nodes::Field do
+        def alias?(val)
+          self.alias == val
+        end
+      end
+
+      refine ::GraphQL::Execution::Lookahead do
+        def selection_with_alias(name, **kwargs)
+          return selection(name, **kwargs) if selects?(name, **kwargs)
+          alias_selection(name, **kwargs)
+        end
+
+        def alias_selection(name, selected_type: @selected_type, arguments: nil)
+          return alias_selections[name] if alias_selections.key?(name)
+
+          alias_node = lookup_alias_node(ast_nodes, name)
+          return ::GraphQL::Execution::Lookahead::NULL_LOOKAHEAD unless alias_node
+
+          next_field_name = alias_node.name
+
+          # From https://github.com/rmosolgo/graphql-ruby/blob/1a9a20f3da629e63ea8e5ee8400be82218f9edc3/lib/graphql/execution/lookahead.rb#L91
+          next_field_defn = get_class_based_field(selected_type, next_field_name)
+
+          alias_selections[name] =
+            if next_field_defn
+              next_nodes = []
+              arguments = @query.arguments_for(alias_node, next_field_defn)
+              arguments = arguments.is_a?(::GraphQL::Execution::Interpreter::Arguments) ? arguments.keyword_arguments : arguments
+              @ast_nodes.each do |ast_node|
+                ast_node.selections.each do |selection|
+                  find_selected_nodes(selection, next_field_name, next_field_defn, arguments: arguments, matches: next_nodes)
+                end
+              end
+
+              if next_nodes.any?
+                ::GraphQL::Execution::Lookahead.new(query: @query, ast_nodes: next_nodes, field: next_field_defn, owner_type: selected_type)
+              else
+                ::GraphQL::Execution::Lookahead::NULL_LOOKAHEAD
+              end
+            else
+              ::GraphQL::Execution::Lookahead::NULL_LOOKAHEAD
+            end
+        end
+
+        def alias_selections
+          return @alias_selections if defined?(@alias_selections)
+          @alias_selections ||= {}
+        end
+
+        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
+          end
+        end
+      end
     })
 
     # Builds cache key for fragment
@@ -59,7 +130,12 @@ module GraphQL
 
       def selections_cache_key
         current_root =
-          path.reduce(query.lookahead) { |lkhd, name| lkhd.selection(name) }
+          path.reduce(query.lookahead) { |lkhd, field_name|
+            # Handle cached fields inside collections:
+            next lkhd if field_name.is_a?(Integer)
+
+            lkhd.selection_with_alias(field_name)
+          }
 
         current_root.selections.to_selections_key
       end
@@ -68,12 +144,16 @@ module GraphQL
         lookahead = query.lookahead
 
         path.map { |field_name|
-          lookahead = lookahead.selection(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)
 
-          next 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(",")
-          "#{field_name}(#{args})"
+          "#{lookahead.field.name}(#{args})"
         }.join("/")
       end
 

data/lib/graphql-fragment_cache.rb

@@ -1,6 +1,6 @@
 require "ruby-next"
 
 require "ruby-next/language/setup"
-RubyNext::Language.setup_gem_load_path
+RubyNext::Language.setup_gem_load_path(transpile: true)
 
 require "graphql/fragment_cache"

data/lib/graphql/fragment_cache.rb

@@ -4,10 +4,11 @@ require "graphql"
 
 require "graphql/fragment_cache/ext/context_fragments"
 require "graphql/fragment_cache/ext/graphql_cache_key"
-
-require "graphql/fragment_cache/schema_patch"
 require "graphql/fragment_cache/object"
-require "graphql/fragment_cache/instrumentation"
+
+require "graphql/fragment_cache/schema/patch"
+require "graphql/fragment_cache/schema/tracer"
+require "graphql/fragment_cache/schema/instrumentation"
 
 require "graphql/fragment_cache/memory_store"
 
@@ -22,8 +23,9 @@ module GraphQL
       def use(schema_defn, options = {})
         verify_interpreter!(schema_defn)
 
-        schema_defn.instrument(:query, Instrumentation)
-        schema_defn.extend(SchemaPatch)
+        schema_defn.tracer(Schema::Tracer)
+        schema_defn.instrument(:query, Schema::Instrumentation)
+        schema_defn.extend(Schema::Patch)
       end
 
       def cache_store=(store)

data/lib/graphql/fragment_cache/cache_key_builder.rb

@@ -18,6 +18,77 @@ module GraphQL
           }.join(".")
         end
       end
+
+      refine ::GraphQL::Language::Nodes::AbstractNode do
+        def alias?(_)
+          false
+        end
+      end
+
+      refine ::GraphQL::Language::Nodes::Field do
+        def alias?(val)
+          self.alias == val
+        end
+      end
+
+      refine ::GraphQL::Execution::Lookahead do
+        def selection_with_alias(name, **kwargs)
+          return selection(name, **kwargs) if selects?(name, **kwargs)
+          alias_selection(name, **kwargs)
+        end
+
+        def alias_selection(name, selected_type: @selected_type, arguments: nil)
+          return alias_selections[name] if alias_selections.key?(name)
+
+          alias_node = lookup_alias_node(ast_nodes, name)
+          return ::GraphQL::Execution::Lookahead::NULL_LOOKAHEAD unless alias_node
+
+          next_field_name = alias_node.name
+
+          # From https://github.com/rmosolgo/graphql-ruby/blob/1a9a20f3da629e63ea8e5ee8400be82218f9edc3/lib/graphql/execution/lookahead.rb#L91
+          next_field_defn = get_class_based_field(selected_type, next_field_name)
+
+          alias_selections[name] =
+            if next_field_defn
+              next_nodes = []
+              arguments = @query.arguments_for(alias_node, next_field_defn)
+              arguments = arguments.is_a?(::GraphQL::Execution::Interpreter::Arguments) ? arguments.keyword_arguments : arguments
+              @ast_nodes.each do |ast_node|
+                ast_node.selections.each do |selection|
+                  find_selected_nodes(selection, next_field_name, next_field_defn, arguments: arguments, matches: next_nodes)
+                end
+              end
+
+              if next_nodes.any?
+                ::GraphQL::Execution::Lookahead.new(query: @query, ast_nodes: next_nodes, field: next_field_defn, owner_type: selected_type)
+              else
+                ::GraphQL::Execution::Lookahead::NULL_LOOKAHEAD
+              end
+            else
+              ::GraphQL::Execution::Lookahead::NULL_LOOKAHEAD
+            end
+        end
+
+        def alias_selections
+          return @alias_selections if defined?(@alias_selections)
+          @alias_selections ||= {}
+        end
+
+        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
+          end
+        end
+      end
     })
 
     # Builds cache key for fragment
@@ -59,7 +130,12 @@ module GraphQL
 
       def selections_cache_key
         current_root =
-          path.reduce(query.lookahead) { |lkhd, name| lkhd.selection(name) }
+          path.reduce(query.lookahead) { |lkhd, field_name|
+            # Handle cached fields inside collections:
+            next lkhd if field_name.is_a?(Integer)
+
+            lkhd.selection_with_alias(field_name)
+          }
 
         current_root.selections.to_selections_key
       end
@@ -68,12 +144,16 @@ module GraphQL
         lookahead = query.lookahead
 
         path.map { |field_name|
-          lookahead = lookahead.selection(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)
 
-          next field_name if lookahead.arguments.empty?
+          next lookahead.field.name if lookahead.arguments.empty?
 
           args = lookahead.arguments.map { "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")
-          "#{field_name}(#{args})"
+          "#{lookahead.field.name}(#{args})"
         }.join("/")
       end
 

data/lib/graphql/fragment_cache/cacher.rb

@@ -10,9 +10,7 @@ module GraphQL
         def call(query)
           return unless query.context.fragments?
 
-          final_value = query.context.namespace(:interpreter)[:runtime].final_value
-
-          query.context.fragments.each { _1.persist(final_value) }
+          query.context.fragments.each(&:persist)
         end
       end
     end

data/lib/graphql/fragment_cache/fragment.rb

@@ -8,18 +8,26 @@ module GraphQL
     class Fragment
       attr_reader :options, :path, :context
 
+      attr_accessor :resolved_value
+
       def initialize(context, **options)
         @context = context
         @options = options
-        @path = context.namespace(:interpreter)[:current_path]
+        @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(final_value)
-        value = resolve(final_value)
+      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
         FragmentCache.cache_store.write(cache_key, value, **options)
       end
 
@@ -29,9 +37,17 @@ module GraphQL
         @cache_key ||= CacheKeyBuilder.call(path: path, query: context.query, **options)
       end
 
-      def resolve(final_value)
+      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
     end
   end
 end

data/lib/graphql/fragment_cache/memory_store.rb

@@ -23,6 +23,10 @@ module GraphQL
         @storage = {}
       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

@@ -8,21 +8,42 @@ module GraphQL
 
     # Adds #cache_fragment method
     module ObjectHelpers
+      extend Forwardable
+
       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
 
         options[:object] = object_to_cache if object_to_cache != NO_OBJECT
+
         fragment = Fragment.new(context, options)
 
         if (cached = fragment.read)
-          return raw_value(cached)
+          return nil if cached == Fragment::NIL_IN_CACHE
+          return restore_cached_value(cached)
+        end
+
+        (block_given? ? block.call : object_to_cache).tap do |resolved_value|
+          context.fragments << fragment
         end
+      end
+
+      private
 
-        context.fragments << fragment
+      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
 
-        block_given? ? block.call : object_to_cache
+      def interpreter_context
+        @interpreter_context ||= context.namespace(:interpreter)
       end
     end
   end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "graphql/fragment_cache/cacher"
+
+module GraphQL
+  module FragmentCache
+    module Schema
+      # Adds hook for saving cached values after query is resolved
+      module Instrumentation
+        module_function
+
+        def before_query(query)
+        end
+
+        def after_query(query)
+          return unless query.valid?
+
+          Cacher.call(query)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "digest/sha1"
+
+module GraphQL
+  module FragmentCache
+    module Schema
+      # Patches GraphQL::Schema to support fragment cache
+      module Patch
+        def schema_cache_key
+          @schema_cache_key ||= Digest::SHA1.hexdigest(to_definition)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module GraphQL
+  # Plugin definition
+  module FragmentCache
+    module Schema
+      class Tracer
+        using Ext
+
+        class << self
+          def trace(key, data)
+            yield.tap do |resolved_value|
+              next unless connection_to_cache?(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)
+            end
+          end
+
+          private
+
+          def connection_to_cache?(key, data)
+            key == "execute_field" && data[:field].connection?
+          end
+
+          def verify_connections!(context)
+            return if context.schema.new_connections?
+
+            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
+  end
+end

data/lib/graphql/fragment_cache/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module FragmentCache
-    VERSION = "0.1.4"
+    VERSION = "1.0.1"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-fragment_cache
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 1.0.1
 platform: ruby
 authors:
 - DmitryTsepelev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-25 00:00:00.000000000 Z
+date: 2020-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.10.3
+        version: 1.10.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.10.3
+        version: 1.10.8
 - !ruby/object:Gem::Dependency
-  name: ruby-next-core
+  name: ruby-next
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.1
+        version: 0.7.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.1
+        version: 0.7.0
 - !ruby/object:Gem::Dependency
   name: combustion
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +52,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -121,7 +149,6 @@ files:
 - bin/console
 - bin/setup
 - lib/.rbnext/2.7/graphql/fragment_cache/cache_key_builder.rb
-- lib/.rbnext/2.7/graphql/fragment_cache/cacher.rb
 - lib/.rbnext/2.7/graphql/fragment_cache/ext/graphql_cache_key.rb
 - lib/graphql-fragment_cache.rb
 - lib/graphql/fragment_cache.rb
@@ -131,13 +158,14 @@ files:
 - lib/graphql/fragment_cache/ext/graphql_cache_key.rb
 - lib/graphql/fragment_cache/field_extension.rb
 - lib/graphql/fragment_cache/fragment.rb
-- lib/graphql/fragment_cache/instrumentation.rb
 - lib/graphql/fragment_cache/memory_store.rb
 - lib/graphql/fragment_cache/object.rb
 - lib/graphql/fragment_cache/object_helpers.rb
 - lib/graphql/fragment_cache/rails/cache_key_builder.rb
 - lib/graphql/fragment_cache/railtie.rb
-- lib/graphql/fragment_cache/schema_patch.rb
+- lib/graphql/fragment_cache/schema/instrumentation.rb
+- lib/graphql/fragment_cache/schema/patch.rb
+- lib/graphql/fragment_cache/schema/tracer.rb
 - lib/graphql/fragment_cache/version.rb
 homepage: https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache
 licenses:

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

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL
-  module FragmentCache
-    using Ext
-
-    # Saves resolved fragment values to cache store
-    module Cacher
-      class << self
-        def call(query)
-          return unless query.context.fragments?
-
-          final_value = query.context.namespace(:interpreter)[:runtime].final_value
-
-          query.context.fragments.each { |_1| _1.persist(final_value) }
-        end
-      end
-    end
-  end
-end

data/lib/graphql/fragment_cache/instrumentation.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require "graphql/fragment_cache/cacher"
-
-module GraphQL
-  module FragmentCache
-    # Adds hook for saving cached values after query is resolved
-    module Instrumentation
-      module_function
-
-      def before_query(query)
-      end
-
-      def after_query(query)
-        return unless query.valid?
-
-        Cacher.call(query)
-      end
-    end
-  end
-end

data/lib/graphql/fragment_cache/schema_patch.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-require "digest/sha1"
-
-module GraphQL
-  module FragmentCache
-    # Patches GraphQL::Schema to support fragment cache
-    module SchemaPatch
-      def schema_cache_key
-        @schema_cache_key ||= Digest::SHA1.hexdigest(to_definition)
-      end
-    end
-  end
-end