graphql-fragment_cache 1.20.5 → 1.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 241af11e5f9aa966c8c544a72a4dc2a92f63267e503636962b198b658727c9d8
-  data.tar.gz: 4e4abd9fbc612dcdbd534466e3ea86f72f990117a98970573b1ffc66d4305bfc
+  metadata.gz: c2f7385deb55dd824ed24ca60059bba372ad645bd2d1a183dee49089b2788648
+  data.tar.gz: 991e976fc7d2a6451e7362e6d899829511d4979544aaf2f01cff25b210782f47
 SHA512:
-  metadata.gz: 994673b1241a0de72655671fc7b3de19fa182191ed41263c184138a5a79ef338e8d167d51d54193131bbd3fb4af281caa72df3308748cf98a2f8478fb40b7029
-  data.tar.gz: a2d13a3eb6f124cac0e5820afeac651c29e7b087649a350fe92dc29ba719b3bd5257fed7896a15a3e5332ba6502275096f36cd991b2aad0696846bcb52acb840
+  metadata.gz: 07ac9a5d1ba73da5561a7c433499486986ccbc9b70c07ea2aaf22b4781d331cd16ca8e9e05005cea2031d5955a188cb5d96431d04439ae229ad97441d913627c
+  data.tar.gz: b9fb29e2a1d1a3bf24808b6186802d4c093764d11a5b80b07e6db8cb97c9454dbff6b878bd5c3767288ff551ee560573ce8ec3834fb01375a3a24aee312bad1c

data/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## master
 
+## 1.22.0 (2025-02-20)
+
+- [PR#134](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/134) Add possibility to include and exclude arguments from generated cache key ([@mgruner][])
+
+## 1.21.0 (2025-02-01)
+
+- [PR#130](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/130) Dataloader support ([@DmitryTsepelev][])
+- [PR#125](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/125) Introduce cache lookup instrumentation hook ([@danielhartnell][])
+
 ## 1.20.5 (2024-11-02)
 
 - [PR#120](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/120) Fix warning on ActiveSupport::Cache.format_version ([@Drowze][])
@@ -211,3 +220,5 @@
 [@diegofigueroa]: https://github.com/diegofigueroa
 [@noma4i]: https://github.com/noma4i
 [@Drowze]: https://github.com/Drowze
+[@danielhartnell]: https://github.com/danielhartnell
+[@mgruner]: https://github.com/mgruner

data/README.md

@@ -147,6 +147,34 @@ class QueryType < BaseObject
 end
 ```
 
+### Query arguments processing
+
+You can influence the way that graphql arguments are include in the cache key.
+
+A use case might be a `:renew_cache` parameter that can be used to force a cache rewrite,
+but should not be included with the cache key itself. Use `cache_key: { exclude_arguments: […]}`
+to specify a list of arguments to be excluded from the implicit cache key.
+
+```ruby
+class QueryType < BaseObject
+  field :post, PostType, null: true do
+    argument :id, ID, required: true
+    argument :renew_cache, Boolean, required: false
+  end
+
+  def post(id:, renew_cache: false)
+    if renew_cache
+      context.scoped_set!(:renew_cache, true)
+    end
+    cache_fragment(cache_key: {exclude_arguments: [:renew_cache]}) { Post.find(id) }
+  end
+end
+```
+
+Likewise, you can use `cache_key: { include_arguments: […] }` to specify an allowlist of arguments
+to be included in the cache key. In this case all arguments for the cache key must be specified, including
+parent arguments of nested fields.
+
 ### User-provided cache key (custom key)
 
 In most cases you want your cache key to depend on the resolved object (say, `ActiveRecord` model). You can do that by passing an argument to the `#cache_fragment` method in a similar way to Rails views [`#cache` method](https://guides.rubyonrails.org/caching_with_rails.html#fragment-caching):
@@ -381,6 +409,34 @@ class QueryType < BaseObject
 end
 ```
 
+## Dataloader
+
+If you are using [Dataloader](https://graphql-ruby.org/dataloader/overview.html), you will need to let the gem know using `dataloader: true`:
+
+```ruby
+class PostType < BaseObject
+  field :author, User, null: false
+
+  def author
+    cache_fragment(dataloader: true) do
+      dataloader.with(AuthorDataloaderSource).load(object.id)
+    end
+  end
+end
+
+# or
+
+class PostType < BaseObject
+  field :author, User, null: false, cache_fragment: {dataloader: true}
+
+  def author
+    dataloader.with(AuthorDataloaderSource).load(object.id)
+  end
+end
+```
+
+The problem is that I didn't find a way to detect that dataloader (and, therefore, Fiber) is used, and the block is forced to resolve, causing the N+1 inside the Dataloader Source class.
+
 ## How to use `#cache_fragment` in extensions (and other places where context is not available)
 
 If you want to call `#cache_fragment` from places other that fields or resolvers, you'll need to pass `context` explicitly and turn on `raw_value` support. For instance, let's take a look at this extension:
@@ -446,6 +502,30 @@ Cache processing can be disabled if needed. For example:
 GraphQL::FragmentCache.enabled = false if Rails.env.test?
 ```
 
+## Cache lookup monitoring
+
+It may be useful to capture cache lookup events. When monitoring is enabled, the `cache_key`, `operation_name`, `path` and a boolean indicating a cache hit or miss will be sent to a `cache_lookup_event` method. This method can be implemented in your application to handle the event.
+
+Example handler defined in a Rails initializer:
+
+```ruby
+module GraphQL
+  module FragmentCache
+    class Fragment
+      def self.cache_lookup_event(**args)
+        # Monitoring such as incrementing a cache hit counter metric
+      end
+    end
+  end
+end
+```
+
+Like managing caching itself, monitoring can be enabled if needed. It is disabled by default. For example:
+
+```ruby
+GraphQL::FragmentCache.monitoring_enabled = true
+```
+
 ## Limitations
 
 1. `Schema#execute`, [graphql-batch](https://github.com/Shopify/graphql-batch) and _graphql-ruby-fragment_cache_ do not [play well](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/issues/45) together. The problem appears when `cache_fragment` is _inside_ the `.then` block:
@@ -477,7 +557,7 @@ end
 field :cached_avatar_url, String, null: false
 
 def cached_avatar_url
-  cache_fragment(query_cache_key: "post_avatar_url(#{object.id})") { object.avatar_url }
+  cache_fragment(path_cache_key: "post_avatar_url(#{object.id})") { object.avatar_url }
 end
 ```
 

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

@@ -14,7 +14,7 @@ module GraphQL
         def traverse_argument(argument)
           return argument unless argument.is_a?(GraphQL::Schema::InputObject)
 
-          "{#{argument.map { |_1, _2| "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")}}"
+          "{#{argument.map { |name, arg| "#{name}:#{traverse_argument(arg)}" }.sort.join(",")}}"
         end
 
         def to_selections_key
@@ -26,7 +26,7 @@ module GraphQL
             field_name = "#{field_alias}:#{field_name}" unless field_alias.empty?
 
             unless val.arguments.empty?
-              args = val.arguments.map { |_1, _2| "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")
+              args = val.arguments.map { |name, arg| "#{name}:#{traverse_argument(arg)}" }.sort.join(",")
               field_name += "(#{args})"
             end
 
@@ -53,64 +53,66 @@ module GraphQL
           alias_selection(name, **kwargs)
         end
 
-        def alias_selection(name, selected_type: @selected_type, arguments: nil)
-          return alias_selections[name] if alias_selections.key?(name)
+        if GraphRubyVersion.before_2_1_4?
+          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
+            alias_node = lookup_alias_node(ast_nodes, name)
+            return ::GraphQL::Execution::Lookahead::NULL_LOOKAHEAD unless alias_node
 
-          next_field_name = alias_node.name
+            next_field_name = alias_node.name
 
-          # From https://github.com/rmosolgo/graphql-ruby/blob/1a9a20f3da629e63ea8e5ee8400be82218f9edc3/lib/graphql/execution/lookahead.rb#L91
-          next_field_defn =
-            if GraphQL::FragmentCache.graphql_ruby_before_2_0?
-              get_class_based_field(selected_type, next_field_name)
-            else
-              @query.get_field(selected_type, next_field_name)
-            end
+            # From https://github.com/rmosolgo/graphql-ruby/blob/1a9a20f3da629e63ea8e5ee8400be82218f9edc3/lib/graphql/execution/lookahead.rb#L91
+            next_field_defn =
+              if GraphRubyVersion.before_2_0?
+                get_class_based_field(selected_type, next_field_name)
+              else
+                @query.get_field(selected_type, next_field_name)
+              end
 
-          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|
-                  if GraphQL::FragmentCache.graphql_ruby_after_2_0_13? && GraphQL::FragmentCache.graphql_ruby_before_2_1_4?
-                    find_selected_nodes(selection, next_field_defn, arguments: arguments, matches: next_nodes)
-                  else
-                    find_selected_nodes(selection, next_field_name, next_field_defn, arguments: arguments, matches: next_nodes)
+            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|
+                    if GraphRubyVersion.after_2_0_13? && GraphRubyVersion.before_2_1_4?
+                      find_selected_nodes(selection, next_field_defn, arguments: arguments, matches: next_nodes)
+                    else
+                      find_selected_nodes(selection, next_field_name, next_field_defn, arguments: arguments, matches: next_nodes)
+                    end
                   end
                 end
-              end
 
-              if next_nodes.any?
-                ::GraphQL::Execution::Lookahead.new(query: @query, ast_nodes: next_nodes, field: next_field_defn, owner_type: selected_type)
+                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
-            else
-              ::GraphQL::Execution::Lookahead::NULL_LOOKAHEAD
-            end
-        end
+          end
 
-        def alias_selections
-          return @alias_selections if defined?(@alias_selections)
-          @alias_selections ||= {}
-        end
+          def alias_selections
+            return @alias_selections if defined?(@alias_selections)
+            @alias_selections ||= {}
+          end
 
-        def lookup_alias_node(nodes, name)
-          return if nodes.empty?
+          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
+            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
+              return node if node.alias?(name)
+              child = lookup_alias_node(node.children, name)
+              return child if child
+            end
           end
         end
       end
@@ -195,7 +197,7 @@ module GraphQL
 
             next lookahead.field.name if lookahead.arguments.empty?
 
-            args = lookahead.arguments.map { |_1, _2| "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")
+            args = lookahead.arguments.map { |name, arg| "#{name}:#{traverse_argument(arg)}" }.sort.join(",")
             "#{lookahead.field.name}(#{args})"
           }.join("/")
         end
@@ -204,7 +206,7 @@ module GraphQL
       def traverse_argument(argument)
         return argument unless argument.is_a?(GraphQL::Schema::InputObject)
 
-        "{#{argument.map { |_1, _2| "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")}}"
+        "{#{argument.map { |name, arg| "#{name}:#{traverse_argument(arg)}" }.sort.join(",")}}"
       end
 
       def object_cache_key

data/lib/graphql/fragment_cache/cache_key_builder.rb

@@ -3,8 +3,6 @@
 require "json"
 require "digest"
 
-using RubyNext
-
 module GraphQL
   module FragmentCache
     using Ext
@@ -52,76 +50,11 @@ module GraphQL
           return selection(name, **kwargs) if selects?(name, **kwargs)
           alias_selection(name, **kwargs)
         end
-
-        if GraphRubyVersion.before_2_1_4?
-          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 =
-              if GraphRubyVersion.before_2_0?
-                get_class_based_field(selected_type, next_field_name)
-              else
-                @query.get_field(selected_type, next_field_name)
-              end
-
-            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|
-                    if GraphRubyVersion.after_2_0_13? && GraphRubyVersion.before_2_1_4?
-                      find_selected_nodes(selection, next_field_defn, arguments: arguments, matches: next_nodes)
-                    else
-                      find_selected_nodes(selection, next_field_name, next_field_defn, arguments: arguments, matches: next_nodes)
-                    end
-                  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
       end
     })
 
     # Builds cache key for fragment
     class CacheKeyBuilder
-      using RubyNext
-
       class << self
         def call(**options)
           new(**options).build
@@ -197,16 +130,26 @@ module GraphQL
 
             next lookahead.field.name if lookahead.arguments.empty?
 
-            args = lookahead.arguments.map { "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")
+            args = lookahead.arguments.select { include_argument?(_1) }.map { "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")
             "#{lookahead.field.name}(#{args})"
           }.join("/")
         end
       end
 
+      def include_argument?(argument_name)
+        exclude_arguments = @options.dig(:cache_key, :exclude_arguments)
+        return false if exclude_arguments&.include?(argument_name)
+
+        include_arguments = @options.dig(:cache_key, :include_arguments)
+        return false if include_arguments && !include_arguments.include?(argument_name)
+
+        true
+      end
+
       def traverse_argument(argument)
         return argument unless argument.is_a?(GraphQL::Schema::InputObject)
 
-        "{#{argument.map { "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")}}"
+        "{#{argument.map { include_argument?(_1) ? "#{_1}:#{traverse_argument(_2)}" : nil }.compact.sort.join(",")}}"
       end
 
       def object_cache_key

data/lib/graphql/fragment_cache/fragment.rb

@@ -16,12 +16,10 @@ module GraphQL
             return fragments.map { |f| [f, f.read] }.to_h
           end
 
-          fragments_to_cache_keys = fragments
-            .map { |f| [f, f.cache_key] }.to_h
+          fragments_to_cache_keys = fragments.map { |f| [f, f.cache_key] }.to_h
 
           # Filter out all the cache_keys for fragments with renew_cache: true in their context
-          cache_keys = fragments_to_cache_keys
-            .reject { |k, _v| k.context[:renew_cache] == true }.values
+          cache_keys = fragments_to_cache_keys.reject { |k, _v| k.context[:renew_cache] == true }.values
 
           # If there are cache_keys look up values with read_multi otherwise return an empty hash
           cache_keys_to_values = if cache_keys.empty?
@@ -30,9 +28,23 @@ module GraphQL
             FragmentCache.cache_store.read_multi(*cache_keys)
           end
 
+          if GraphQL::FragmentCache.monitoring_enabled
+            begin
+              fragments.map do |fragment|
+                cache_lookup_event(
+                  cache_key: fragment.cache_key,
+                  operation_name: fragment.context.query.operation_name,
+                  path: fragment.path,
+                  cache_hit: cache_keys_to_values.key?(fragment.cache_key)
+                )
+              end
+            rescue
+              # Allow cache_lookup_event to fail when we do not have all of the requested attributes
+            end
+          end
+
           # Fragmenst without values or with renew_cache: true in their context will have nil values like the read method
-          fragments_to_cache_keys
-            .map { |fragment, cache_key| [fragment, cache_keys_to_values[cache_key]] }.to_h
+          fragments_to_cache_keys.map { |fragment, cache_key| [fragment, cache_keys_to_values[cache_key]] }.to_h
         end
       end
 
@@ -87,6 +99,11 @@ module GraphQL
       def final_value
         @final_value ||= context.query.result["data"]
       end
+
+      def cache_lookup_event(**args)
+        # This method can be implemented in your application
+        # This provides a mechanism to monitor cache hits for a fragment
+      end
     end
   end
 end

data/lib/graphql/fragment_cache/graphql_ruby_version.rb

@@ -1,24 +1,10 @@
 # frozen_string_literal: true
 
-using RubyNext
-
 module GraphQL
   module FragmentCache
     module GraphRubyVersion
       module_function
 
-      def before_2_0?
-        check_graphql_version "< 2.0.0"
-      end
-
-      def after_2_0_13?
-        check_graphql_version "> 2.0.13"
-      end
-
-      def before_2_1_4?
-        check_graphql_version "< 2.1.4"
-      end
-
       def after_2_2_5?
         check_graphql_version "> 2.2.5"
       end

data/lib/graphql/fragment_cache/memory_store.rb

@@ -1,13 +1,9 @@
 # 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

data/lib/graphql/fragment_cache/railtie.rb

@@ -26,7 +26,9 @@ module GraphQL
 
       if ENV["RACK_ENV"] == "test" || ENV["RAILS_ENV"] == "test"
         initializer "graphql-fragment_cache" do
-          config.graphql_fragment_cache.store = if Rails.version.to_f >= 7.0
+          config.graphql_fragment_cache.store = if Rails.version.to_f >= 8.0
+            [:null_store]
+          elsif Rails.version.to_f >= 7.0
             [:null_store, serializer: :marshal_7_0]
           else
             :null_store

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

@@ -16,6 +16,8 @@ module GraphQL
           @block = block
 
           @lazy_state[:pending_fragments] << @fragment
+
+          ensure_dataloader_resulution! if @fragment.options[:dataloader]
         end
 
         def resolve
@@ -35,6 +37,15 @@ module GraphQL
             @query_ctx.fragments << @fragment
           end
         end
+
+        private
+
+        def ensure_dataloader_resulution!
+          return if FragmentCache.cache_store.exist?(@fragment.cache_key)
+
+          @object_to_cache = @block.call
+          @block = nil
+        end
       end
     end
   end

data/lib/graphql/fragment_cache/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module FragmentCache
-    VERSION = "1.20.5"
+    VERSION = "1.22.0"
   end
 end

data/lib/graphql/fragment_cache.rb

@@ -25,14 +25,13 @@ module GraphQL
     class << self
       attr_reader :cache_store
       attr_accessor :enabled
+      attr_accessor :monitoring_enabled
       attr_accessor :namespace
       attr_accessor :default_options
 
       attr_accessor :skip_cache_when_query_has_errors
 
       def use(schema_defn, options = {})
-        verify_interpreter_and_analysis!(schema_defn)
-
         if GraphRubyVersion.after_2_2_5?
           schema_defn.trace_with(Schema::Instrumentation::Tracer)
         else
@@ -69,24 +68,11 @@ module GraphQL
       def check_graphql_version(predicate)
         Gem::Dependency.new("graphql", predicate).match?("graphql", GraphQL::VERSION)
       end
-
-      def verify_interpreter_and_analysis!(schema_defn)
-        if GraphRubyVersion.before_2_0?
-          unless schema_defn.interpreter?
-            raise StandardError,
-              "GraphQL::Execution::Interpreter should be enabled for fragment caching"
-          end
-
-          unless schema_defn.analysis_engine == GraphQL::Analysis::AST
-            raise StandardError,
-              "GraphQL::Analysis::AST should be enabled for fragment caching"
-          end
-        end
-      end
     end
 
     self.cache_store = MemoryStore.new
     self.enabled = true
+    self.monitoring_enabled = false
     self.namespace = "graphql"
     self.default_options = {}
     self.skip_cache_when_query_has_errors = false

data/lib/graphql-fragment_cache.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-fragment_cache
 version: !ruby/object:Gem::Version
-  version: 1.20.5
+  version: 1.22.0
 platform: ruby
 authors:
 - DmitryTsepelev
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-02 00:00:00.000000000 Z
+date: 2025-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -16,28 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: 2.1.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.0
-- !ruby/object:Gem::Dependency
-  name: ruby-next
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.15.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.15.0
+        version: 2.1.4
 - !ruby/object:Gem::Dependency
   name: combustion
   requirement: !ruby/object:Gem::Requirement
@@ -70,16 +56,16 @@ dependencies:
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -122,20 +108,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: ruby-next
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0.10'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0.10'
 - !ruby/object:Gem::Dependency
   name: unparser
   requirement: !ruby/object:Gem::Requirement
@@ -193,8 +165,6 @@ files:
 - lib/.rbnext/2.3/graphql/fragment_cache/cache_key_builder.rb
 - lib/.rbnext/2.3/graphql/fragment_cache/memory_store.rb
 - lib/.rbnext/2.5/graphql/fragment_cache/cacher.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
@@ -230,14 +200,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.0'
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.6
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: Fragment cache for graphql-ruby

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

@@ -1,219 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "digest"
-
-using RubyNext
-
-module GraphQL
-  module FragmentCache
-    using Ext
-
-    using(Module.new {
-      refine Array do
-        def traverse_argument(argument)
-          return argument unless argument.is_a?(GraphQL::Schema::InputObject)
-
-          "{#{argument.map { |_1, _2| "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")}}"
-        end
-
-        def to_selections_key
-          map { |val|
-            children = val.selections.empty? ? "" : "[#{val.selections.to_selections_key}]"
-
-            field_name = val.field.name
-            field_alias = val.ast_nodes.map(&:alias).join
-            field_name = "#{field_alias}:#{field_name}" unless field_alias.empty?
-
-            unless val.arguments.empty?
-              args = val.arguments.map { |_1, _2| "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")
-              field_name += "(#{args})"
-            end
-
-            "#{field_name}#{children}"
-          }.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 =
-            if GraphQL::FragmentCache.graphql_ruby_before_2_0?
-              get_class_based_field(selected_type, next_field_name)
-            else
-              @query.get_field(selected_type, next_field_name)
-            end
-
-          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|
-                  if GraphQL::FragmentCache.graphql_ruby_after_2_0_13? && GraphQL::FragmentCache.graphql_ruby_before_2_1_4?
-                    find_selected_nodes(selection, next_field_defn, arguments: arguments, matches: next_nodes)
-                  else
-                    find_selected_nodes(selection, next_field_name, next_field_defn, arguments: arguments, matches: next_nodes)
-                  end
-                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
-    class CacheKeyBuilder
-      using RubyNext
-
-      class << self
-        def call(**options)
-          new(**options).build
-        end
-      end
-
-      attr_reader :query, :path, :object, :schema
-
-      def initialize(query:, path:, object: nil, **options)
-        @object = object
-        @query = query
-        @schema = query.schema
-        @path = path
-        @options = options
-      end
-
-      def build
-        key_parts = [
-          GraphQL::FragmentCache.namespace,
-          simple_path_cache_key,
-          implicit_cache_key,
-          object_cache_key
-        ]
-
-        key_parts
-          .compact
-          .map { |key_part| key_part.tr("/", "-") }
-          .join("/")
-      end
-
-      private
-
-      def implicit_cache_key
-        Digest::SHA1.hexdigest("#{schema_cache_key}/#{query_cache_key}")
-      end
-
-      def 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}]" }
-      end
-
-      def selections_cache_key
-        current_root =
-          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
-
-      def simple_path_cache_key
-        return if path_cache_key.nil?
-
-        path_cache_key.split("(").first
-      end
-
-      def path_cache_key
-        @path_cache_key ||= @options.fetch(:path_cache_key) do
-          lookahead = query.lookahead
-
-          path.map { |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 lookahead.field.name if lookahead.arguments.empty?
-
-            args = lookahead.arguments.map { |_1, _2| "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")
-            "#{lookahead.field.name}(#{args})"
-          }.join("/")
-        end
-      end
-
-      def traverse_argument(argument)
-        return argument unless argument.is_a?(GraphQL::Schema::InputObject)
-
-        "{#{argument.map { |_1, _2| "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")}}"
-      end
-
-      def object_cache_key
-        @options[:object_cache_key] || object_key(object)
-      end
-
-      def object_key(obj)
-        obj&._graphql_cache_key
-      end
-    end
-  end
-end

data/lib/.rbnext/2.7/graphql/fragment_cache/ext/graphql_cache_key.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL
-  module FragmentCache
-    module Ext
-      # Adds #_graphql_cache_key method to Object,
-      # which just call #graphql_cache_key or #cache_key.
-      #
-      # For other core classes returns string representation.
-      #
-      # Raises ArgumentError otherwise.
-      #
-      # We use a refinement to avoid case/if statements for type checking
-      refine Object do
-        def _graphql_cache_key
-          return graphql_cache_key if respond_to?(:graphql_cache_key)
-          return cache_key if respond_to?(:cache_key)
-          return to_a._graphql_cache_key if respond_to?(:to_a)
-
-          to_s
-        end
-      end
-
-      refine Array do
-        def _graphql_cache_key
-          map { |_1| _1._graphql_cache_key }.join("/")
-        end
-      end
-
-      refine NilClass do
-        def _graphql_cache_key
-          ""
-        end
-      end
-
-      refine TrueClass do
-        def _graphql_cache_key
-          "t"
-        end
-      end
-
-      refine FalseClass do
-        def _graphql_cache_key
-          "f"
-        end
-      end
-
-      refine String do
-        def _graphql_cache_key
-          self
-        end
-      end
-
-      refine Symbol do
-        def _graphql_cache_key
-          to_s
-        end
-      end
-
-      if RUBY_PLATFORM.match?(/java/i)
-        refine Integer do
-          def _graphql_cache_key
-            to_s
-          end
-        end
-
-        refine Float do
-          def _graphql_cache_key
-            to_s
-          end
-        end
-      else
-        refine Numeric do
-          def _graphql_cache_key
-            to_s
-          end
-        end
-      end
-
-      refine Time do
-        def _graphql_cache_key
-          to_s
-        end
-      end
-
-      refine Module do
-        def _graphql_cache_key
-          name
-        end
-      end
-    end
-  end
-end