graphql-fragment_cache 1.22.2 → 1.22.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b58c6a92e1599cb9096dd48fb540e221dd291a3b4864980cf7b618986cf8c1ed
-  data.tar.gz: 5b19fc87c04ed9a92d94cb88f354b317eaf50e77369799effbbe74b5054bf124
+  metadata.gz: 076cc28fcf1a65116b294f3df5422e74a097e00f7568f5265143f6468c5bce35
+  data.tar.gz: e20103b9efc1672e5f0df675ba54eedcc6a2c1a0528227f6eb846fa5a61e41b4
 SHA512:
-  metadata.gz: 6c3243e15ff2abed075c7da99060ed750007aa4298d53a9e1a67ae72dd30cbde3c2a71a1c32e18bb4e6c151e6c1c0c1755c579595d6f0143a9db3b9dbcf2ab38
-  data.tar.gz: '0937e3232dd472d5e51c94cfb4d44b01ede12676472e125a89d4e09ab5ae5e4f2d251df58b64a6e10ad6526fc7a7297a71d98b52b98510c98c13d43f9c352508'
+  metadata.gz: bcb941215e44b94fce0f8dee4dfdd6899ecb1f17f017959ac4c98c95ab9e74f6b609ac5a414ca35c80e853eef0aa69cb919b387f08ac7a9a4079c81e772c5087
+  data.tar.gz: e10156565aaccda651550b94d27c60d217483ce371e17b325342eb6996801cb952bd05320da1e2bc98a80eb24eb6b3cff82e323280e55cf5acbe569fb26efabc

data/CHANGELOG.md

@@ -2,7 +2,14 @@
 
 ## master
 
-## 1.22.1 (2025-06-07)
+## 1.22.3 (2026-11-07)
+
+- [PR#144](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/144) Fix SystemStackError when cache_fragment is used inside a mutation
+ ([@LRFalk01][])
+- [PR#99](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/99) Fix for race condition when reading from cache
+ ([@gsdean][])
+
+## 1.22.2 (2025-06-07)
 
 - [PR#137](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/137) Remove new_connections? check for gql > 2.3.10 in Tracer ([@DmitryTsepelev][])
 
@@ -226,3 +233,5 @@
 [@Drowze]: https://github.com/Drowze
 [@danielhartnell]: https://github.com/danielhartnell
 [@mgruner]: https://github.com/mgruner
+[@gsdean]: https://github.com/gsdean
+[@LRFalk01]: https://github.com/LRFalk01

data/README.md

@@ -9,7 +9,10 @@ class PostType < BaseObject
 end
 ```
 
-You can support my open–source work [here](https://boosty.to/dmitry_tsepelev).
+## Professional Support
+
+Need help with your GraphQL API architecture, schema design, or performance?
+I'm available for consulting — [get in touch](https://dmitrytsepelev.dev/consulting).
 
 ## Getting started
 

data/lib/graphql/fragment_cache/cache_key_builder.rb

@@ -46,9 +46,9 @@ module GraphQL
       end
 
       refine ::GraphQL::Execution::Lookahead do
-        def selection_with_alias(name, **kwargs)
-          return selection(name, **kwargs) if selects?(name, **kwargs)
-          alias_selection(name, **kwargs)
+        def selection_with_alias(name, **)
+          return selection(name, **) if selects?(name, **)
+          alias_selection(name, **)
         end
       end
     })
@@ -56,8 +56,8 @@ module GraphQL
     # Builds cache key for fragment
     class CacheKeyBuilder
       class << self
-        def call(**options)
-          new(**options).build
+        def call(**)
+          new(**).build
         end
       end
 

data/lib/graphql/fragment_cache/fragment.rb

@@ -87,6 +87,8 @@ module GraphQL
       end
 
       def value_from_cache
+        return nil unless FragmentCache.cache_store.exist?(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

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

@@ -25,13 +25,6 @@ module GraphQL
 
         # Instrumentations were deprecated in 2.2.5, this is a module to migrate to new interface
         module Tracer
-          def execute_query(query:)
-            result = super
-          ensure
-            GraphQL::FragmentCache::Schema::Instrumentation.after_query(query)
-            result
-          end
-
           def execute_multiplex(multiplex:)
             result = super
             multiplex.queries.each do |query|

data/lib/graphql/fragment_cache/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module FragmentCache
-    VERSION = "1.22.2"
+    VERSION = "1.22.3"
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: graphql-fragment_cache
 version: !ruby/object:Gem::Version
-  version: 1.22.2
+  version: 1.22.3
 platform: ruby
 authors:
 - DmitryTsepelev
 bindir: bin
 cert_chain: []
-date: 2025-06-07 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -51,6 +51,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: benchmark
+  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
@@ -149,6 +163,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  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'
 description: Fragment cache for graphql-ruby
 email:
 - dmitry.a.tsepelev@gmail.com
@@ -161,9 +189,6 @@ files:
 - README.md
 - bin/console
 - bin/setup
-- 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/graphql-fragment_cache.rb
 - lib/graphql/fragment_cache.rb
 - lib/graphql/fragment_cache/cache_key_builder.rb
@@ -205,7 +230,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Fragment cache for graphql-ruby
 test_files: []

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

@@ -1,221 +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 { |name, arg| "#{name}:#{traverse_argument(arg)}" }.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 { |name, arg| "#{name}:#{traverse_argument(arg)}" }.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
-
-        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
-        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 { |name, arg| "#{name}:#{traverse_argument(arg)}" }.sort.join(",")
-            "#{lookahead.field.name}(#{args})"
-          }.join("/")
-        end
-      end
-
-      def traverse_argument(argument)
-        return argument unless argument.is_a?(GraphQL::Schema::InputObject)
-
-        "{#{argument.map { |name, arg| "#{name}:#{traverse_argument(arg)}" }.sort.join(",")}}"
-      end
-
-      def object_cache_key
-        @options[:object_cache_key] || object_key(object)
-      end
-
-      def object_key(obj)
-        ((((__safe_lvar__ = obj) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__._graphql_cache_key)
-      end
-    end
-  end
-end

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

@@ -1,65 +0,0 @@
-# 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
-        end
-      end
-
-      attr_reader :default_expires_in
-
-      def initialize(expires_in: nil, **other)
-        raise ArgumentError, "Unsupported options: #{other.keys.join(",")}" unless other.empty?
-
-        @default_expires_in = expires_in
-        @storage = {}
-      end
-
-      def keys
-        storage.keys
-      end
-
-      def exist?(key)
-        storage.key?(key)
-      end
-
-      def read(key)
-        key = key.to_s
-        ((((__safe_lvar__ = storage[key]) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.then { |entry|
-  if entry.expired?
-    delete(key)
-    next
-  end
-  entry.value
-})
-      end
-
-      def write(key, value, options = {})
-        expires_in = options[:expires_in] || default_expires_in
-        key = key.to_s
-        @storage[key] = Entry.new(value: value, expires_at: expires_in ? Time.now + expires_in : nil)
-      end
-
-      def delete(key)
-        key = key.to_s
-        storage.delete(key)
-      end
-
-      def clear
-        storage.clear
-      end
-
-      private
-
-      attr_reader :storage
-    end
-  end
-end

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

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL
-  module FragmentCache
-    using Ext
-
-    class WriteError < StandardError
-      attr_reader :key, :value, :original_error
-
-      def initialize(original_error, key, value)
-        @original_error = original_error
-        @key = key
-        @value = value
-
-        super(original_error.message)
-      end
-    end
-
-    class WriteMultiError < StandardError
-      attr_reader :values, :original_error
-
-      def initialize(original_error, values)
-        @original_error = original_error
-        @values = values
-
-        super(original_error.message)
-      end
-    end
-
-    # Saves resolved fragment values to cache store
-    module Cacher
-      class << self
-        def call(query)
-          return unless query.context.fragments?
-
-          if FragmentCache.cache_store.respond_to?(:write_multi)
-            batched_persist(query)
-          else
-            persist(query)
-          end
-        end
-
-        private
-
-        def batched_persist(query)
-          select_valid_fragments(query).group_by(&:options).each do |options, group|
-            hash = group.map { |fragment| [fragment.cache_key, fragment.value] }.to_h
-
-            begin
-              FragmentCache.cache_store.write_multi(hash, options)
-            rescue => e
-              raise WriteMultiError.new(e, hash)
-            end
-          end
-        end
-
-        def persist(query)
-          select_valid_fragments(query).each do |fragment|
-            begin;FragmentCache.cache_store.write(fragment.cache_key, fragment.value, fragment.options)
-          rescue => e
-            raise WriteError.new(e, fragment.cache_key, fragment.value), e;end
-          end
-        end
-
-        def select_valid_fragments(query)
-          query.context.fragments.select(&:with_final_value?)
-        end
-      end
-    end
-  end
-end