graphql-fragment_cache 0.1.6 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d83b3ff9d3e9cc91b6f013214d2cc4d97c6d2fc8bd377bf38d1f68dd7f935c23
-  data.tar.gz: d349157e8c6856c06b5a3ae76915399ae77fc04153093ef9551bb75b45629cb4
+  metadata.gz: 8fd575d2efddb52ef6d0f878b40823baae40cedec5aa683ba5f6a1b39b98bffe
+  data.tar.gz: eba1c06d3650d395575bd96927f831fc206f797b47afa9ebfcfff9adbf2ecf1d
 SHA512:
-  metadata.gz: 759813c8b9ae4373d9890519aa88573eb9a504771eca25ea7d7ddc2a35b972f172e1fb7e86bbd2f52447886e3c781178cfc7491c9a7257ce436ae411a32395fb
-  data.tar.gz: 78c75d761fc3154dd4a4622a36c5b0f7bbc4b26c31eb4bf3e3c6be4423be8ae64923d7207f02217142c213fa80e039410e2d079403c0258efd82543d9866e41d
+  metadata.gz: 5fe016ab01f8b8076b1cc6680f8a09ad9bf1ab9d7f5c798a308465fd0d6d80dd6da24ef5855aa35660d9b8cce0529ab59cb6a45b7b971c58d4f8a9e761b80ff9
+  data.tar.gz: 0430b991c22524be88e3741f700d5c02ac65186f4cf40e7f06440b737c345bba8e44748a9e8d6ef1293356e21ee7560595b5e1563c28da7bb5f88008f7174360

data/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 ## master
 
+## 1.0.3 (2020-08-31)
+
+- [PR#29](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/29) Cache result JSON instead of connection objects ([@DmitryTsepelev][])
+
+## 1.0.2 (2020-08-19)
+
+- [PR#28](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/28) Support #keys method for GraphQL::FragmentCache::MemoryStore instance ([@reabiliti][])
+
+## 1.0.1 (2020-06-17)
+
+- [PR#25](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/25) Support fragments with aliases for CacheKeyBuilder ([@DmitryTsepelev][])
+
+## 1.0.0 (2020-06-13)
+
+- [PR#24](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/24) Add nil caching. **BREAKING CHANGE**: custom cache stores must also implement `#exist?(key)` method ([@DmitryTsepelev][])
+
+## 0.1.7 (2020-06-02)
+
+- [PR#23](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/23) Avoid extra queries after restoring connection from cache ([@DmitryTsepelev][])
+
 ## 0.1.6 (2020-05-30)
 
 - [PR#22](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache/pull/22) Properly cache entites inside collections ([@DmitryTsepelev][])
@@ -35,3 +55,4 @@
 [@DmitryTsepelev]: https://github.com/DmitryTsepelev
 [@palkan]: https://github.com/palkan
 [@ssnickolay]: https://github.com/ssnickolay
+[@reabiliti]: https://github.com/reabiliti

data/README.md

@@ -252,7 +252,7 @@ Rails.application.configure do |config|
 end
 ```
 
-⚠️ Cache store must implement `#read(key)` and `#write(key, value, **options)` methods.
+⚠️ Cache store must implement `#read(key)`, `#write(key, value, **options)` and `#exist?(key)` methods.
 
 The gem provides only in-memory store out-of-the-box (`GraphQL::FragmentCache::MemoryStore`). It's used by default.
 

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

@@ -76,7 +76,13 @@ module GraphQL
 
         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

data/lib/graphql/fragment_cache.rb

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

data/lib/graphql/fragment_cache/cache_key_builder.rb

@@ -76,7 +76,13 @@ module GraphQL
 
         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

data/lib/graphql/fragment_cache/cacher.rb

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

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module FragmentCache
+    module Connections
+      # Patches GraphQL::Pagination::Connections to support raw values
+      module Patch
+        if Gem::Dependency.new("graphql", ">= 1.11.0").match?("graphql", GraphQL::VERSION)
+          def wrap(field, parent, items, arguments, context, *options)
+            raw_value?(items) ? items : super
+          end
+        else
+          def wrap(field, object, arguments, context, *options)
+            raw_value?(object) ? object : super
+          end
+        end
+
+        private
+
+        def raw_value?(value)
+          GraphQL::Execution::Interpreter::RawValue === value
+        end
+      end
+    end
+  end
+end

data/lib/graphql/fragment_cache/fragment.rb

@@ -6,22 +6,24 @@ module GraphQL
   module FragmentCache
     # Represents a single fragment to cache
     class Fragment
-      attr_reader :options, :path, :context, :raw_connection
-
-      attr_writer :raw_connection
+      attr_reader :options, :path, :context
 
       def initialize(context, **options)
         @context = context
         @options = options
-        @path = context.namespace(:interpreter)[:current_path]
+        @path = interpreter_context[:current_path]
       end
 
+      NIL_IN_CACHE = Object.new
+
       def read
-        FragmentCache.cache_store.read(cache_key)
+        FragmentCache.cache_store.read(cache_key).tap do |cached|
+          return NIL_IN_CACHE if cached.nil? && FragmentCache.cache_store.exist?(cache_key)
+        end
       end
 
-      def persist(final_value)
-        value = raw_connection || resolve(final_value)
+      def persist
+        value = final_value.dig(*path)
         FragmentCache.cache_store.write(cache_key, value, **options)
       end
 
@@ -31,8 +33,12 @@ module GraphQL
         @cache_key ||= CacheKeyBuilder.call(path: path, query: context.query, **options)
       end
 
-      def resolve(final_value)
-        final_value.dig(*path)
+      def interpreter_context
+        context.namespace(:interpreter)
+      end
+
+      def final_value
+        @final_value ||= interpreter_context[:runtime].final_value
       end
     end
   end

data/lib/graphql/fragment_cache/memory_store.rb

@@ -23,6 +23,14 @@ module GraphQL
         @storage = {}
       end
 
+      def keys
+        storage.keys
+      end
+
+      def exist?(key)
+        storage.key?(key)
+      end
+
       def read(key)
         key = key.to_s
         storage[key]&.then do |entry|

data/lib/graphql/fragment_cache/object_helpers.rb

@@ -6,8 +6,6 @@ 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
@@ -24,41 +22,16 @@ module GraphQL
         fragment = Fragment.new(context, options)
 
         if (cached = fragment.read)
-          return restore_cached_value(cached)
+          return cached == Fragment::NIL_IN_CACHE ? nil : raw_value(cached)
         end
 
         (block_given? ? block.call : object_to_cache).tap do |resolved_value|
-          cache_value(resolved_value, fragment)
+          context.fragments << 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
@@ -66,19 +39,6 @@ module GraphQL
       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
-
-      def wrap_connection(object)
-        context.schema.connections.wrap(field, object, interpreter_context[:current_arguments], context)
-      end
     end
   end
 end

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

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

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

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

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module GraphQL
+  # Plugin definition
+  module FragmentCache
+    module Schema
+      class Tracer
+        using Ext
+
+        class << self
+          def trace(key, data)
+            yield.tap do |resolved_value|
+              next unless connection_field?(key, data)
+
+              verify_connections!(data[:query].context)
+            end
+          end
+
+          private
+
+          def connection_field?(key, data)
+            key == "execute_field" && data[:field].connection?
+          end
+
+          def verify_connections!(context)
+            return if context.schema.new_connections?
+
+            raise StandardError,
+              "GraphQL::Pagination::Connections should be enabled for connection caching"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/fragment_cache/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-fragment_cache
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 1.0.3
 platform: ruby
 authors:
 - DmitryTsepelev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-30 00:00:00.000000000 Z
+date: 2020-08-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -136,6 +136,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: ruby-next-parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.8.0.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.8.0.7
 description: Fragment cache for graphql-ruby
 email:
 - dmitry.a.tsepelev@gmail.com
@@ -149,23 +163,24 @@ files:
 - bin/console
 - bin/setup
 - lib/.rbnext/2.7/graphql/fragment_cache/cache_key_builder.rb
-- lib/.rbnext/2.7/graphql/fragment_cache/cacher.rb
 - lib/.rbnext/2.7/graphql/fragment_cache/ext/graphql_cache_key.rb
 - lib/graphql-fragment_cache.rb
 - lib/graphql/fragment_cache.rb
 - lib/graphql/fragment_cache/cache_key_builder.rb
 - lib/graphql/fragment_cache/cacher.rb
+- lib/graphql/fragment_cache/connections/patch.rb
 - lib/graphql/fragment_cache/ext/context_fragments.rb
 - lib/graphql/fragment_cache/ext/graphql_cache_key.rb
 - lib/graphql/fragment_cache/field_extension.rb
 - lib/graphql/fragment_cache/fragment.rb
-- lib/graphql/fragment_cache/instrumentation.rb
 - lib/graphql/fragment_cache/memory_store.rb
 - lib/graphql/fragment_cache/object.rb
 - lib/graphql/fragment_cache/object_helpers.rb
 - lib/graphql/fragment_cache/rails/cache_key_builder.rb
 - lib/graphql/fragment_cache/railtie.rb
-- lib/graphql/fragment_cache/schema_patch.rb
+- lib/graphql/fragment_cache/schema/instrumentation.rb
+- lib/graphql/fragment_cache/schema/patch.rb
+- lib/graphql/fragment_cache/schema/tracer.rb
 - lib/graphql/fragment_cache/version.rb
 homepage: https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache
 licenses:

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

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

data/lib/graphql/fragment_cache/instrumentation.rb

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

data/lib/graphql/fragment_cache/schema_patch.rb

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