graphql-fragment_cache 1.10.0 → 1.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c0987cb1e081b19356cfd389164150d7678c2fff2a479986f56e157ac485e79
-  data.tar.gz: 72cc6cf9a79c003be0c83dc60447840128ba1d8395e60171ce26a5eaf8190f2b
+  metadata.gz: 66fc20ed7d15e85c1d4ce2890d6b28c368a75e3e06ef69ff186470b5a0953567
+  data.tar.gz: 4d0d3f12716b8d4d5be627411121cbdba2d067991ea1d6874f3b2891f2636a4a
 SHA512:
-  metadata.gz: 78be339e321b1c76066e63960d615d85fc286531ba663eef4af3c62baee8b3d598867047cf1c52ca6085b7fca3cbd86ec0038718548e014aff5c8273740a3c9a
-  data.tar.gz: 005efd512fba6e4f91ba5aec08637ce058217f7c2e580ef4afa8c6323fef035a70c72a5abd74d418892f02b607b6e5fff288adfb9830ee9125985b852153775e
+  metadata.gz: 5758f73fc04e6e63246b6d21899891220f4e7a7733561a72b6b652a26a6f7bd602425d95d14d2711f15a90865caf907d78244c253243541fd414fa59c93c4954
+  data.tar.gz: bea6d191cdaba4f7b5ed13250c1d5aaec02e0aafbd44cc8b9d29f5a8dba3718f43db62f683df01d3946ff611603f6dd5a6bba2001344ada4d29143c8aae8291a

data/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## master
 
+## 1.11.0 (2022-02-26)
+
+- [PR#79](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/79) Support graphql-ruby 2.0.0 ([@DmitryTsepelev][])
+
 ## 1.10.0 (2022-01-30)
 
 - [PR#77](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/77) Drop Ruby 2.5 support, add Ruby 3.0 ([@DmitryTsepelev][])

data/README.md

@@ -17,13 +17,10 @@ end
 
 ## Getting started
 
-Add the gem to your Gemfile `gem 'graphql-fragment_cache'` and add the plugin to your schema class (make sure to turn interpreter mode on with AST analysis!):
+Add the gem to your Gemfile `gem 'graphql-fragment_cache'` and add the plugin to your schema class:
 
 ```ruby
 class GraphqSchema < GraphQL::Schema
-  use GraphQL::Execution::Interpreter
-  use GraphQL::Analysis::AST
-
   use GraphQL::FragmentCache
 
   query QueryType
@@ -69,15 +66,6 @@ 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 the following parts: namespace, implicit key, and explicit key.

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

@@ -0,0 +1,203 @@
+# 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|
+                  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
+    class CacheKeyBuilder
+      using RubyNext
+
+      class << self
+        def call(**options)
+          new(**options).build
+        end
+      end
+
+      attr_reader :query, :path, :object, :schema
+
+      def initialize(object: nil, query:, path:, **options)
+        @object = object
+        @query = query
+        @schema = query.schema
+        @path = path
+        @options = options
+      end
+
+      def build
+        [
+          GraphQL::FragmentCache.namespace,
+          implicit_cache_key,
+          object_cache_key
+        ].compact.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 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.nil?) || nil) && obj._graphql_cache_key
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# 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
+        ((!storage[key].nil?) || nil) && storage[key].then do |entry|
+  if entry.expired?
+    delete(key)
+    next
+  end
+  entry.value
+end
+      end
+
+      def write(key, value, expires_in: default_expires_in, **options)
+        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.7/graphql/fragment_cache/cache_key_builder.rb

@@ -0,0 +1,203 @@
+# 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|
+                  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
+    class CacheKeyBuilder
+      using RubyNext
+
+      class << self
+        def call(**options)
+          new(**options).build
+        end
+      end
+
+      attr_reader :query, :path, :object, :schema
+
+      def initialize(object: nil, query:, path:, **options)
+        @object = object
+        @query = query
+        @schema = query.schema
+        @path = path
+        @options = options
+      end
+
+      def build
+        [
+          GraphQL::FragmentCache.namespace,
+          implicit_cache_key,
+          object_cache_key
+        ].compact.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 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

@@ -0,0 +1,93 @@
+# 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

data/lib/graphql/fragment_cache/cache_key_builder.rb

@@ -62,7 +62,12 @@ module GraphQL
           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)
+          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

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

@@ -23,7 +23,7 @@ module GraphQL
           end
 
           def verify_connections!(context)
-            return if GraphQL::FragmentCache.graphql_ruby_1_12_or_later? || context.schema.new_connections?
+            return if context.schema.new_connections?
 
             raise StandardError,
               "GraphQL::Pagination::Connections should be enabled for connection caching"

data/lib/graphql/fragment_cache/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module FragmentCache
-    VERSION = "1.10.0"
+    VERSION = "1.11.0"
   end
 end

data/lib/graphql/fragment_cache.rb

@@ -50,29 +50,20 @@ module GraphQL
         @cache_store = store
       end
 
-      def graphql_ruby_1_12_or_later?
-        Gem::Dependency.new("graphql", ">= 1.12.0").match?("graphql", GraphQL::VERSION)
+      def graphql_ruby_before_2_0?
+        Gem::Dependency.new("graphql", "< 2.0.0").match?("graphql", GraphQL::VERSION)
       end
 
       private
 
       def verify_interpreter_and_analysis!(schema_defn)
-        if graphql_ruby_1_12_or_later?
-          unless schema_defn.interpreter?
-            raise StandardError,
-              "GraphQL::Execution::Execute should not be enabled for fragment caching"
-          end
-
-          unless schema_defn.analysis_engine == GraphQL::Analysis::AST
-            raise StandardError,
-              "GraphQL::Analysis should not be enabled for fragment caching"
-          end
-        else
+        if graphql_ruby_before_2_0?
           unless schema_defn.interpreter?
             raise StandardError,
               "GraphQL::Execution::Interpreter should be enabled for fragment caching"
           end
 
+          puts "schema_defn.analysis_engine #{schema_defn.analysis_engine}"
           unless schema_defn.analysis_engine == GraphQL::Analysis::AST
             raise StandardError,
               "GraphQL::Analysis::AST should be enabled for fragment caching"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-fragment_cache
 version: !ruby/object:Gem::Version
-  version: 1.10.0
+  version: 1.11.0
 platform: ruby
 authors:
 - DmitryTsepelev
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-30 00:00:00.000000000 Z
+date: 2022-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.10.8
+        version: 1.12.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.10.8
+        version: 1.12.0
 - !ruby/object:Gem::Dependency
   name: ruby-next
   requirement: !ruby/object:Gem::Requirement
@@ -190,6 +190,10 @@ 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.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
@@ -215,7 +219,7 @@ metadata:
   homepage_uri: https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache
   source_code_uri: https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache
   changelog_uri: https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/CHANGELOG.md
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -230,8 +234,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
-signing_key: 
+rubygems_version: 3.3.7
+signing_key:
 specification_version: 4
 summary: Fragment cache for graphql-ruby
 test_files: []