graphql-fragment_cache 0.1.1 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f11f53d4ee61fae49c514e17afe6eca9711c78578e7573ad79626cb222c2bdcf
-  data.tar.gz: 2022a81f41d7318f74255c42a86ce022acee957f4ad60324d4f6638e0bc97044
+  metadata.gz: d83b3ff9d3e9cc91b6f013214d2cc4d97c6d2fc8bd377bf38d1f68dd7f935c23
+  data.tar.gz: d349157e8c6856c06b5a3ae76915399ae77fc04153093ef9551bb75b45629cb4
 SHA512:
-  metadata.gz: 3a5772dc50d5e9bf398c42f7c50bb58fe565b6897a59a7488a289e5dbc0f594897dfb4af05f611770bdc9dd2693c1c78b3ae5a4e7e183df9c2ef076f321a1e9c
-  data.tar.gz: 2570227cfeef325af92d6e32df92624d5c11c2b04f0cc9f964d72641c61e0a9ddaf3add4dec3260d98707096ec0ec00aecaba01b66137e35d44f66659c2323cb
+  metadata.gz: 759813c8b9ae4373d9890519aa88573eb9a504771eca25ea7d7ddc2a35b972f172e1fb7e86bbd2f52447886e3c781178cfc7491c9a7257ce436ae411a32395fb
+  data.tar.gz: 78c75d761fc3154dd4a4622a36c5b0f7bbc4b26c31eb4bf3e3c6be4423be8ae64923d7207f02217142c213fa80e039410e2d079403c0258efd82543d9866e41d

data/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 ## master
 
+## 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][])
+
+## 0.1.3 (2020-04-24)
+
+- [PR#17](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/17) Properly build cache keys based on input arguments ([@DmitryTsepelev][])
+
+## 0.1.2 (2020-04-24)
+
+- [PR#16](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/16) Railtie turns off caching in test environment ([@DmitryTsepelev][])
+- [PR#15](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/15) Avoid extra resolving when resolved_value is not used for building cache key ([@DmitryTsepelev][])
+
 ## 0.1.1 (2020-04-15)
 
 - Fix using passed object as a cache key ([@palkan][])

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.
@@ -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,71 @@ 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|
+            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 +124,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,15 +138,25 @@ 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}:#{_2}" }.sort.join(",")
-          "#{field_name}(#{args})"
+          args = lookahead.arguments.map { |_1, _2| "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")
+          "#{lookahead.field.name}(#{args})"
         }.join("/")
       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_key(obj)
         obj._graphql_cache_key
       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

@@ -12,7 +12,6 @@ require "graphql/fragment_cache/instrumentation"
 require "graphql/fragment_cache/memory_store"
 
 require "graphql/fragment_cache/version"
-require "graphql/fragment_cache/railtie" if defined?(Rails::Railtie)
 
 module GraphQL
   # Plugin definition
@@ -57,3 +56,5 @@ module GraphQL
     self.cache_store = MemoryStore.new
   end
 end
+
+require "graphql/fragment_cache/railtie" if defined?(Rails::Railtie)

data/lib/graphql/fragment_cache/cache_key_builder.rb

@@ -18,6 +18,71 @@ 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|
+            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 +124,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,15 +138,25 @@ 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}" }.sort.join(",")
-          "#{field_name}(#{args})"
+          args = lookahead.arguments.map { "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")
+          "#{lookahead.field.name}(#{args})"
         }.join("/")
       end
 
+      def traverse_argument(argument)
+        return argument unless argument.is_a?(GraphQL::Schema::InputObject)
+
+        "{#{argument.map { "#{_1}:#{traverse_argument(_2)}" }.sort.join(",")}}"
+      end
+
       def object_key(obj)
         obj._graphql_cache_key
       end

data/lib/graphql/fragment_cache/field_extension.rb

@@ -34,20 +34,24 @@ module GraphQL
         @cache_key = @cache_options.delete(:cache_key)
       end
 
+      NOT_RESOLVED = Object.new
+
       def resolve(object:, arguments:, **_options)
-        resolved_value = yield(object, arguments)
+        resolved_value = NOT_RESOLVED
 
         object_for_key = if @context_key
           Array(@context_key).map { |key| object.context[key] }
         elsif @cache_key == :object
           object.object
         elsif @cache_key == :value
-          resolved_value
+          resolved_value = yield(object, arguments)
         end
 
         cache_fragment_options = @cache_options.merge(object: object_for_key)
 
-        object.cache_fragment(cache_fragment_options) { resolved_value }
+        object.cache_fragment(cache_fragment_options) do
+          resolved_value == NOT_RESOLVED ? yield(object, arguments) : resolved_value
+        end
       end
     end
   end

data/lib/graphql/fragment_cache/fragment.rb

@@ -6,7 +6,9 @@ module GraphQL
   module FragmentCache
     # Represents a single fragment to cache
     class Fragment
-      attr_reader :options, :path, :context
+      attr_reader :options, :path, :context, :raw_connection
+
+      attr_writer :raw_connection
 
       def initialize(context, **options)
         @context = context
@@ -19,7 +21,7 @@ module GraphQL
       end
 
       def persist(final_value)
-        value = resolve(final_value)
+        value = raw_connection || resolve(final_value)
         FragmentCache.cache_store.write(cache_key, value, **options)
       end
 

data/lib/graphql/fragment_cache/object_helpers.rb

@@ -6,23 +6,78 @@ module GraphQL
   module FragmentCache
     using Ext
 
+    RawConnection = Struct.new(:items, :nodes, :paged_nodes_offset, :has_previous_page, :has_next_page)
+
     # 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 restore_cached_value(cached)
+        end
+
+        (block_given? ? block.call : object_to_cache).tap do |resolved_value|
+          cache_value(resolved_value, fragment)
+        end
+      end
+
+      private
+
+      def restore_cached_value(cached)
+        connection? ? restore_cached_connection(cached) : raw_value(cached)
+      end
+
+      def cache_value(resolved_value, fragment)
+        if connection?
+          unless context.schema.new_connections?
+            raise StandardError,
+              "GraphQL::Pagination::Connections should be enabled for connection caching"
+          end
+
+          connection = wrap_connection(resolved_value)
+
+          fragment.raw_connection = RawConnection.new(
+            connection.items,
+            connection.nodes,
+            connection.instance_variable_get(:@paged_nodes_offset),
+            connection.has_previous_page,
+            connection.has_next_page
+          )
         end
 
         context.fragments << fragment
+      end
+
+      def field
+        interpreter_context[:current_field]
+      end
+
+      def interpreter_context
+        @interpreter_context ||= context.namespace(:interpreter)
+      end
+
+      def restore_cached_connection(raw_connection)
+        wrap_connection(raw_connection.items).tap do |connection|
+          connection.instance_variable_set(:@nodes, raw_connection.nodes)
+          connection.instance_variable_set(:@paged_nodes_offset, raw_connection.paged_nodes_offset)
+          connection.instance_variable_set(:@has_previous_page, raw_connection.has_previous_page)
+          connection.instance_variable_set(:@has_next_page, raw_connection.has_next_page)
+        end
+      end
 
-        block_given? ? block.call : object_to_cache
+      def wrap_connection(object)
+        context.schema.connections.wrap(field, object, interpreter_context[:current_arguments], context)
       end
     end
   end

data/lib/graphql/fragment_cache/railtie.rb

@@ -23,6 +23,10 @@ module GraphQL
       end
 
       config.graphql_fragment_cache = Config
+
+      if ENV["RACK_ENV"] == "test" || ENV["RAILS_ENV"] == "test"
+        config.graphql_fragment_cache.store = :null_store
+      end
     end
   end
 end

data/lib/graphql/fragment_cache/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module FragmentCache
-    VERSION = "0.1.1"
+    VERSION = "0.1.6"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-fragment_cache
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.6
 platform: ruby
 authors:
 - DmitryTsepelev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-15 00:00:00.000000000 Z
+date: 2020-05-30 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
@@ -100,14 +128,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.5'
+        version: '0.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.5'
+        version: '0.6'
 description: Fragment cache for graphql-ruby
 email:
 - dmitry.a.tsepelev@gmail.com